Cache Cost Optimization: Reducing Redis Infrastructure Costs

import redis
import json

r = redis.Redis(decode_responses=True)

class CacheRightSizer:
    def __init__(self, redis_client):
        self.r = redis_client

    def analyze_usage(self):
        """Analyze current cache usage and recommend sizing."""
        info = self.r.info("memory")
        keyspace = self.r.info("keyspace")

        used_memory = info.get("used_memory", 0)
        maxmemory = info.get("maxmemory", 0)
        peak_memory = info.get("used_memory_peak", 0)

        total_keys = 0
        for db, db_info in keyspace.items():
            if db.startswith("db"):
                parts = str(db_info).split(",")
                for part in parts:
                    if "keys=" in part:
                        total_keys += int(part.split("=")[1])

        return {
            "current_used_mb": round(used_memory / 1024 / 1024, 1),
            "current_peak_mb": round(peak_memory / 1024 / 1024, 1),
            "maxmemory_mb": round(maxmemory / 1024 / 1024, 1) if maxmemory else None,
            "total_keys": total_keys,
            "avg_bytes_per_key": round(used_memory / total_keys) if total_keys else 0,
            "utilization_pct": round(used_memory / maxmemory * 100, 1) if maxmemory else None,
        }

    def recommend_instance_size(self):
        """Recommend optimal instance size based on usage."""
        usage = self.analyze_usage()

        peak_mb = usage["current_peak_mb"]
        headroom = peak_mb * 1.5
        recommended_mb = max(peak_mb + 1024, headroom)

        tier_options = {
            "t3-micro": {"memory_mb": 500, "cost_monthly": 15},
            "t3-small": {"memory_mb": 1500, "cost_monthly": 35},
            "r6g-large": {"memory_mb": 13000, "cost_monthly": 120},
            "r6g-xlarge": {"memory_mb": 26000, "cost_monthly": 240},
            "r6g-2xlarge": {"memory_mb": 52000, "cost_monthly": 480},
            "r6g-4xlarge": {"memory_mb": 105000, "cost_monthly": 960},
        }

        best_tier = None
        for tier, specs in tier_options.items():
            if specs["memory_mb"] >= recommended_mb:
                best_tier = {"name": tier, **specs}
                break

        current_cost = 120
        if best_tier:
            savings = current_cost - best_tier["cost_monthly"]
            return {
                "current": usage,
                "recommended": best_tier,
                "monthly_savings": round(max(0, savings), 2),
                "annual_savings": round(max(0, savings * 12), 2),
                "notes": [
                    f"Peak usage: {usage['current_peak_mb']}MB",
                    f"Recommended: {best_tier['name']} ({best_tier['memory_mb']}MB)",
                    f"Headroom: {(best_tier['memory_mb'] - peak_mb) / peak_mb * 100:.0f}%",
                ],
            }
        return {"current": usage, "recommended": None}

sizer = CacheRightSizer(r)
recommendation = sizer.recommend_instance_size()

print("Current Usage Analysis:")
for key, value in recommendation['current'].items():
    print(f"  {key}: {value}")

print(f"\nRecommendation:")
rec = recommendation['recommended']
if rec:
    print(f"  Instance: {rec['name']} ({rec['memory_mb']}MB, ${rec['cost_monthly']}/mo)")
    print(f"  Monthly savings: ${recommendation['monthly_savings']}")
    print(f"  Annual savings: ${recommendation['annual_savings']}")

for note in recommendation.get("notes", []):
    print(f"  Note: {note}")

import redis
import json

r = redis.Redis(decode_responses=True)

class MemoryOptimizerCost:
    def __init__(self, redis_client):
        self.r = redis_client

    def estimate_savings(self, current_size_mb, key_count, avg_value_size):
        """Estimate cost savings from various optimization techniques."""
        current_overhead_per_key = 200
        current_total = current_size_mb

        scenarios = {
            "baseline": {
                "description": "Current setup",
                "total_mb": current_total,
                "cost_monthly": round(current_total * 0.012, 2),
            },
            "compression_zstd": {
                "description": "Compress values with zstd (70% reduction)",
                "total_mb": round(current_total * 0.4, 1),
                "cost_monthly": round(current_total * 0.4 * 0.012, 2),
                "implementation": "Add zstd compression to cache wrapper (2 days work)",
            },
            "hash_storage": {
                "description": "Store small objects as hashes (40% overhead reduction)",
                "total_mb": round(current_total * 0.75, 1),
                "cost_monthly": round(current_total * 0.75 * 0.012, 2),
                "implementation": "Convert string-stored JSON to hash data type (3 days work)",
            },
            "better_eviction": {
                "description": "Switch to allkeys-lfu (15% fewer evictions, 10% better hit rate)",
                "total_mb": current_total,
                "cost_monthly": round(current_total * 0.012, 2),
                "improvement": "10% hit rate improvement = 10% fewer database calls",
            },
            "combined": {
                "description": "All optimizations combined",
                "total_mb": round(current_total * 0.35, 1),
                "cost_monthly": round(current_total * 0.35 * 0.012, 2),
            },
        }

        baseline = scenarios["baseline"]["cost_monthly"]
        results = {}
        for name, scenario in scenarios.items():
            savings = baseline - scenario["cost_monthly"]
            results[name] = {
                **scenario,
                "monthly_savings": round(savings, 2),
                "annual_savings": round(savings * 12, 2),
            }

        return results

optimizer = MemoryOptimizerCost(r)

costs = optimizer.estimate_savings(current_size_mb=512, key_count=500000, avg_value_size=500)

print(f"{'Scenario':25s} {'Size':8s} {'Cost/mo':10s} {'Savings/mo':10s} {'Savings/yr':10s}")
print("-" * 63)
for name, data in costs.items():
    size = f"{data['total_mb']}MB"
    print(f"{name:25s} {size:8s} ${data['cost_monthly']:<8.2f} "
          f"${data['monthly_savings']:<8.2f} ${data['annual_savings']:<8.2f}")