Lambda Cold Start — Causes and Mitigation Strategies

# measure_cold_start.py
# Simulating cold start measurement

import time

def measure_invocation(warm=False):
    start = time.time()
    
    if not warm:
        print("[Cold] Provisioning container...")
        time.sleep(1.5)
        print("[Cold] Initializing runtime...")
        time.sleep(0.3)
        print("[Cold] Loading dependencies...")
        time.sleep(0.2)
    
    time.sleep(0.05)  # Handler execution
    elapsed = (time.time() - start) * 1000
    return elapsed

print("Measuring cold vs warm start latency:")
cold = measure_invocation(warm=False)
warm1 = measure_invocation(warm=True)
warm2 = measure_invocation(warm=True)
warm3 = measure_invocation(warm=True)

print(f"\nCold start:  {cold:.0f}ms")
print(f"Warm start 1: {warm1:.0f}ms")
print(f"Warm start 2: {warm2:.0f}ms")
print(f"Warm start 3: {warm3:.0f}ms")
print(f"Cold start penalty: {cold - warm1:.0f}ms")

# provisioned_concurrency.py
# Understanding provisioned concurrency

class LambdaConfig:
    def __init__(self, name, provisioned=0, reserved=0):
        self.name = name
        self.provisioned = provisioned
        self.reserved = reserved
    
    def handle_request(self, is_cold=False):
        if self.provisioned > 0:
            latency = 50  # Warm from provisioned
            self.provisioned -= 1
            source = "provisioned"
        elif is_cold:
            latency = 2000
            source = "cold"
        else:
            latency = 50
            source = "warm"
        
        print(f"[{self.name}] Response in {latency}ms ({source})")
        return latency

config = LambdaConfig("API-Function", provisioned=5, reserved=10)

print("First 5 requests (provisioned - no cold starts):")
for i in range(5):
    config.handle_request()

print("\nNext request (if no provisioned remaining, could be cold):")
config.handle_request(is_cold=False)

# optimization.py
# Cold start optimization strategies

def simulate_cold_start(package_size_mb, runtime, use_snapstart=False):
    base = 200  # Base container setup
    
    if use_snapstart:
        runtime_penalty = 50
    elif runtime == "python":
        runtime_penalty = 200
    elif runtime == "nodejs":
        runtime_penalty = 150
    elif runtime == "java":
        runtime_penalty = 1500
    elif runtime == "go":
        runtime_penalty = 100
    else:
        runtime_penalty = 300
    
    package_penalty = package_size_mb * 30
    total = base + runtime_penalty + package_penalty
    
    print(f"Runtime: {runtime:8s} | Package: {package_size_mb}MB | SnapStart: {use_snapstart}")
    print(f"  Cold start estimate: {total}ms")
    print(f"  Breakdown: base={base}ms + runtime={runtime_penalty}ms + package={package_penalty}ms")
    return total

print("Cold start optimization comparison:\n")
simulate_cold_start(3, "python")
simulate_cold_start(3, "nodejs")
simulate_cold_start(50, "java", use_snapstart=False)
simulate_cold_start(50, "java", use_snapstart=True)
simulate_cold_start(1, "go")

import json
import time
import random

COLD_START_LOG = []

class ColdStartMonitor:
    def __init__(self):
        self.cold = True
    
    def invoke(self, function_name):
        is_cold = self.cold
        self.cold = False
        
        if is_cold:
            latency = random.randint(800, 2500)
        else:
            latency = random.randint(10, 100)
        
        COLD_START_LOG.append({"function": function_name, "cold": is_cold, "latency": latency})
        return {"function": function_name, "cold": is_cold, "latency": latency}

def check_cold_start_rate():
    total = len(COLD_START_LOG)
    cold = sum(1 for e in COLD_START_LOG if e["cold"])
    rate = cold / total * 100 if total > 0 else 0
    print(f"Total invocations: {total}, Cold starts: {cold}, Rate: {rate:.1f}%")
    if rate > 1:
        print("ALERT: Cold start rate exceeds 1% threshold!")
    return rate

monitor = ColdStartMonitor()
for i in range(100):
    monitor.invoke("user-api")
    if i == 20:
        monitor.cold = True  # Simulate idle period
    time.sleep(0.01)

check_cold_start_rate()