claude-autopm 2.8.2 → 2.8.4

package/packages/plugin-databases/scripts/examples/bigquery-cost-analyze.sh

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+# BigQuery cost analysis and optimization checker
+# Usage: ./bigquery-cost-analyze.sh [project-id] [dataset]
+
+set -euo pipefail
+
+PROJECT_ID="${1:-}"
+DATASET="${2:-}"
+
+if [ -z "$PROJECT_ID" ]; then
+    echo "Usage: $0 <project-id> [dataset]"
+    exit 1
+fi
+
+echo "💰 Analyzing BigQuery costs and optimization opportunities..."
+echo "Project: $PROJECT_ID"
+if [ -n "$DATASET" ]; then
+    echo "Dataset: $DATASET"
+fi
+
+# Check if bq CLI is installed
+if ! command -v bq &> /dev/null; then
+    echo "❌ bq CLI not found. Please install Google Cloud SDK."
+    exit 1
+fi
+
+# Get storage costs
+echo ""
+echo "📊 Storage Analysis:"
+if [ -n "$DATASET" ]; then
+    QUERY="
+    SELECT
+        table_schema as dataset,
+        table_name,
+        ROUND(total_logical_bytes / POW(10, 9), 2) as logical_gb,
+        ROUND(total_physical_bytes / POW(10, 9), 2) as physical_gb,
+        ROUND(long_term_logical_bytes / POW(10, 9), 2) as long_term_gb,
+        CASE
+            WHEN total_rows > 0 THEN ROUND(total_physical_bytes / total_rows, 2)
+            ELSE 0
+        END as bytes_per_row
+    FROM \`region-us\`.INFORMATION_SCHEMA.TABLE_STORAGE
+    WHERE table_schema = '$DATASET'
+    ORDER BY total_physical_bytes DESC
+    LIMIT 10;
+    "
+else
+    QUERY="
+    SELECT
+        table_schema as dataset,
+        SUM(total_physical_bytes) / POW(10, 9) as total_physical_gb,
+        SUM(long_term_physical_bytes) / POW(10, 9) as long_term_gb
+    FROM \`region-us\`.INFORMATION_SCHEMA.TABLE_STORAGE
+    GROUP BY table_schema
+    ORDER BY total_physical_gb DESC
+    LIMIT 10;
+    "
+fi
+
+bq query --use_legacy_sql=false --format=prettyjson "$QUERY" 2>/dev/null | head -50
+
+# Check for partitioning and clustering
+echo ""
+echo "🗂️  Partitioning and Clustering Status:"
+if [ -n "$DATASET" ]; then
+    PARTITION_QUERY="
+    SELECT
+        table_name,
+        CASE
+            WHEN is_partitioning_column = 'YES' THEN 'Partitioned'
+            ELSE 'Not Partitioned'
+        END as partition_status,
+        CASE
+            WHEN clustering_ordinal_position IS NOT NULL THEN 'Clustered'
+            ELSE 'Not Clustered'
+        END as cluster_status
+    FROM \`$PROJECT_ID.$DATASET.INFORMATION_SCHEMA.COLUMNS\`
+    WHERE table_name NOT LIKE '%INFORMATION_SCHEMA%'
+    GROUP BY table_name, partition_status, cluster_status
+    ORDER BY table_name;
+    "
+    bq query --use_legacy_sql=false --format=prettyjson "$PARTITION_QUERY" 2>/dev/null | head -50
+fi
+
+# Check recent query costs
+echo ""
+echo "💸 Most Expensive Queries (Last 7 Days):"
+EXPENSIVE_QUERY="
+SELECT
+    user_email,
+    query,
+    ROUND(total_bytes_processed / POW(10, 9), 2) as gb_processed,
+    ROUND(total_slot_ms / 1000, 2) as slot_seconds,
+    TIMESTAMP_DIFF(end_time, start_time, MILLISECOND) as duration_ms
+FROM \`$PROJECT_ID.region-us.INFORMATION_SCHEMA.JOBS_BY_PROJECT\`
+WHERE creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
+    AND job_type = 'QUERY'
+    AND state = 'DONE'
+    AND total_bytes_processed > 0
+ORDER BY total_bytes_processed DESC
+LIMIT 5;
+"
+bq query --use_legacy_sql=false --format=prettyjson "$EXPENSIVE_QUERY" 2>/dev/null | head -100
+
+echo ""
+echo "📋 Best practices from Context7 (/websites/cloud_google-bigquery):"
+echo ""
+echo "🗂️  Partitioning:"
+echo "  ✓ Partition tables by DATE or TIMESTAMP for time-series data"
+echo "  ✓ Use PARTITION BY DATE(timestamp_column) for daily partitions"
+echo "  ✓ Set partition_expiration_days to automatically remove old data"
+echo "  ✓ Use require_partition_filter=TRUE to enforce partition filtering"
+echo ""
+echo "Example:"
+echo "  CREATE TABLE dataset.events ("
+echo "    event_id INT64,"
+echo "    event_timestamp TIMESTAMP"
+echo "  )"
+echo "  PARTITION BY DATE(event_timestamp)"
+echo "  OPTIONS (partition_expiration_days=365);"
+echo ""
+echo "🎯 Clustering:"
+echo "  ✓ Cluster by columns frequently used in WHERE and GROUP BY"
+echo "  ✓ Order clustering columns by cardinality (low to high)"
+echo "  ✓ Up to 4 clustering columns supported"
+echo "  ✓ Clustering improves query performance and reduces costs"
+echo ""
+echo "Example:"
+echo "  CREATE TABLE dataset.events ("
+echo "    event_timestamp TIMESTAMP,"
+echo "    user_id STRING,"
+echo "    event_type STRING"
+echo "  )"
+echo "  PARTITION BY DATE(event_timestamp)"
+echo "  CLUSTER BY user_id, event_type;"
+echo ""
+echo "💰 Cost Optimization:"
+echo "  ✓ Use _PARTITIONTIME for partition pruning in WHERE clauses"
+echo "  ✓ Avoid SELECT * - specify only needed columns"
+echo "  ✓ Use LIMIT for exploratory queries"
+echo "  ✓ Preview data with table preview (free)"
+echo "  ✓ Use materialized views for repeated aggregations"
+echo "  ✓ Monitor INFORMATION_SCHEMA.TABLE_STORAGE for storage costs"
+echo "  ✓ Long-term storage (90+ days) is 50% cheaper"
+echo ""
+echo "🚀 Query Optimization:"
+echo "  ✓ Place _PARTITIONTIME on left side of comparisons"
+echo "  ✓ Use constant expressions for partition pruning"
+echo "  ✓ Combine filters with AND for multiple partition columns"
+echo "  ✓ Use ORDER BY + LIMIT for search queries on partitioned tables"
+echo ""
+echo "Example optimized query:"
+echo "  SELECT event_type, COUNT(*) as total"
+echo "  FROM dataset.events"
+echo "  WHERE DATE(event_timestamp) BETWEEN '2024-01-01' AND '2024-01-31'"
+echo "    AND user_id = 'user123'"
+echo "  GROUP BY event_type;"
+
+echo ""
+echo "✅ BigQuery cost analysis complete"

package/packages/plugin-databases/scripts/examples/cosmosdb-ru-optimize.sh

@@ -0,0 +1,163 @@
+#!/usr/bin/env bash
+# Azure Cosmos DB RU/s optimization and partition analysis
+# Usage: ./cosmosdb-ru-optimize.sh [resource-group] [account-name] [database] [container]
+
+set -euo pipefail
+
+RESOURCE_GROUP="${1:-}"
+ACCOUNT_NAME="${2:-}"
+DATABASE="${3:-}"
+CONTAINER="${4:-}"
+
+if [ -z "$RESOURCE_GROUP" ] || [ -z "$ACCOUNT_NAME" ] || [ -z "$DATABASE" ] || [ -z "$CONTAINER" ]; then
+    echo "Usage: $0 <resource-group> <account-name> <database> <container>"
+    exit 1
+fi
+
+echo "🔍 Analyzing Azure Cosmos DB RU/s and partition distribution..."
+echo "Resource Group: $RESOURCE_GROUP"
+echo "Account: $ACCOUNT_NAME"
+echo "Database: $DATABASE"
+echo "Container: $CONTAINER"
+
+# Check if az CLI is installed
+if ! command -v az &> /dev/null; then
+    echo "❌ Azure CLI not found. Please install Azure CLI."
+    exit 1
+fi
+
+# Get current throughput
+echo ""
+echo "📊 Current Throughput Configuration:"
+az cosmosdb sql container throughput show \
+    --resource-group "$RESOURCE_GROUP" \
+    --account-name "$ACCOUNT_NAME" \
+    --database-name "$DATABASE" \
+    --name "$CONTAINER" \
+    --query "{throughput: resource.throughput, autoscale: resource.autoscaleSettings}" \
+    --output table 2>/dev/null || echo "  ℹ️  Using database-level shared throughput"
+
+# Get container properties
+echo ""
+echo "🗂️  Container Properties:"
+az cosmosdb sql container show \
+    --resource-group "$RESOURCE_GROUP" \
+    --account-name "$ACCOUNT_NAME" \
+    --database-name "$DATABASE" \
+    --name "$CONTAINER" \
+    --query "{partitionKey: resource.partitionKey.paths[0], ttl: resource.defaultTtl, indexingPolicy: resource.indexingPolicy.indexingMode}" \
+    --output table
+
+# Check for partition distribution (requires connection)
+echo ""
+echo "⚖️  Partition Distribution Analysis:"
+echo "  ℹ️  Use Azure Portal Metrics or Application Insights for detailed partition metrics"
+echo "  📊 Recommended checks:"
+echo "    - Normalized RU Consumption (should be balanced across partitions)"
+echo "    - Storage per partition (should be evenly distributed)"
+echo "    - Hot partition detection (> 50% RU consumption on single partition)"
+
+# Get consistency level
+echo ""
+echo "🎯 Consistency Level:"
+az cosmosdb show \
+    --resource-group "$RESOURCE_GROUP" \
+    --name "$ACCOUNT_NAME" \
+    --query "consistencyPolicy.defaultConsistencyLevel" \
+    --output tsv
+
+echo ""
+echo "📋 Best practices from Context7 (/websites/learn_microsoft-en-us-azure-cosmos-db):"
+echo ""
+echo "🔑 Partition Key Selection:"
+echo "  ✓ Choose high-cardinality partition key (many distinct values)"
+echo "  ✓ Distribute read and write operations evenly"
+echo "  ✓ Avoid hot partitions (single partition handling most traffic)"
+echo "  ✓ Common patterns:"
+echo "    - User ID for user-centric applications"
+echo "    - Tenant ID for multi-tenant applications"
+echo "    - Date + ID composite for time-series data"
+echo ""
+echo "⚖️  Consistency Levels (by use case):"
+echo "  • Strong: Financial transactions, inventory systems"
+echo "  • Bounded Staleness: Social media feeds, leaderboards"
+echo "  • Session: Shopping carts, user preferences (MOST COMMON)"
+echo "  • Consistent Prefix: Live scores, news feeds"
+echo "  • Eventual: Analytics, telemetry, logs"
+echo ""
+echo "💰 RU/s Optimization:"
+echo "  ✓ Use autoscale for unpredictable workloads"
+echo "  ✓ Use manual throughput for consistent workloads"
+echo "  ✓ Monitor normalized RU consumption (should be 70-85%)"
+echo "  ✓ Distribute throughput evenly across partitions"
+echo ""
+echo "Example: Evenly distribute RU/s across partitions:"
+echo "  az cosmosdb sql container redistribute-partition-throughput \\"
+echo "    --resource-group '$RESOURCE_GROUP' \\"
+echo "    --account-name '$ACCOUNT_NAME' \\"
+echo "    --database-name '$DATABASE' \\"
+echo "    --name '$CONTAINER' \\"
+echo "    --evenly-distribute"
+echo ""
+echo "🕒 TTL (Time-to-Live):"
+echo "  ✓ Set defaultTtl for automatic data expiration"
+echo "  ✓ Per-item TTL for granular control"
+echo "  ✓ Reduces storage costs and improves query performance"
+echo ""
+echo "Example: Enable TTL on container:"
+echo "  az cosmosdb sql container update \\"
+echo "    --resource-group '$RESOURCE_GROUP' \\"
+echo "    --account-name '$ACCOUNT_NAME' \\"
+echo "    --database-name '$DATABASE' \\"
+echo "    --name '$CONTAINER' \\"
+echo "    --ttl 86400  # 24 hours"
+echo ""
+echo "📊 Query Optimization:"
+echo "  ✓ Include partition key in WHERE clause when possible"
+echo "  ✓ Use composite indexes for multi-property queries"
+echo "  ✓ Limit result set size with TOP"
+echo "  ✓ Use OFFSET/LIMIT for pagination"
+echo "  ✓ Avoid cross-partition queries when possible"
+echo ""
+echo "Example optimized query:"
+echo "  SELECT * FROM c"
+echo "  WHERE c.userId = 'user123'  -- Partition key"
+echo "    AND c.timestamp > '2024-01-01'"
+echo "  ORDER BY c.timestamp DESC"
+echo "  OFFSET 0 LIMIT 20"
+echo ""
+echo "🌍 Global Distribution:"
+echo "  ✓ Enable multi-region writes for low latency globally"
+echo "  ✓ Use Session consistency for global applications"
+echo "  ✓ Configure read regions based on user distribution"
+echo "  ✓ Monitor cross-region replication lag"
+echo ""
+echo "💡 Cost Optimization Tips:"
+echo "  1. Right-size RU/s based on actual usage (monitor normalized RU consumption)"
+echo "  2. Use shared database throughput for small containers"
+echo "  3. Implement TTL to automatically remove old data"
+echo "  4. Use serverless for development/test environments"
+echo "  5. Archive cold data to Azure Blob Storage"
+echo "  6. Optimize indexing policy (exclude unused properties)"
+
+# Check if container uses composite indexes
+echo ""
+echo "🔍 Checking Indexing Policy:"
+az cosmosdb sql container show \
+    --resource-group "$RESOURCE_GROUP" \
+    --account-name "$ACCOUNT_NAME" \
+    --database-name "$DATABASE" \
+    --name "$CONTAINER" \
+    --query "resource.indexingPolicy" \
+    --output json 2>/dev/null | head -30
+
+echo ""
+echo "✅ Cosmos DB RU/s optimization analysis complete"
+echo ""
+echo "📌 Next Steps:"
+echo "  1. Review partition distribution in Azure Portal Metrics"
+echo "  2. Check for hot partitions (> 50% normalized RU consumption)"
+echo "  3. Verify consistency level matches application requirements"
+echo "  4. Implement TTL if not already configured"
+echo "  5. Consider autoscale for variable workloads"
+echo "  6. Monitor query RU charges and optimize high-cost queries"

package/packages/plugin-databases/scripts/examples/mongodb-shard-check.sh

@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+# MongoDB sharded collection index consistency check
+# Usage: ./mongodb-shard-check.sh [database] [collection]
+
+set -euo pipefail
+
+DB_NAME="${1:-test}"
+COLLECTION="${2:-users}"
+
+echo "🔍 Checking MongoDB sharded collection index consistency..."
+echo "Database: $DB_NAME"
+echo "Collection: $COLLECTION"
+
+# Create temporary JavaScript file for aggregation pipeline
+TEMP_JS=$(mktemp)
+cat > "$TEMP_JS" << 'EOJS'
+const pipeline = [
+    // Get indexes and the shards that they belong to
+    {$indexStats: {}},
+    // Attach a list of all shards which reported indexes
+    {$group: {_id: null, indexDoc: {$push: "$$ROOT"}, allShards: {$addToSet: "$shard"}}},
+    // Unwind the generated array back
+    {$unwind: "$indexDoc"},
+    // Group by index name
+    {
+        $group: {
+            "_id": "$indexDoc.name",
+            "shards": {$push: "$indexDoc.shard"},
+            "specs": {$push: {$objectToArray: {$ifNull: ["$indexDoc.spec", {}]}}},
+            "allShards": {$first: "$allShards"}
+        }
+    },
+    // Compute which indexes are not present on all shards
+    {
+        $project: {
+            missingFromShards: {$setDifference: ["$allShards", "$shards"]},
+            inconsistentProperties: {
+                 $setDifference: [
+                     {$reduce: {
+                         input: "$specs",
+                         initialValue: {$arrayElemAt: ["$specs", 0]},
+                         in: {$setUnion: ["$$value", "$$this"]}}},
+                     {$reduce: {
+                         input: "$specs",
+                         initialValue: {$arrayElemAt: ["$specs", 0]},
+                         in: {$setIntersection: ["$$value", "$$this"]}}}
+                 ]
+             }
+        }
+    },
+    // Only return inconsistencies
+    {
+        $match: {
+            $expr: {$or: [
+                {$gt: [{$size: "$missingFromShards"}, 0]},
+                {$gt: [{$size: "$inconsistentProperties"}, 0]}
+            ]}
+        }
+    },
+    // Output relevant fields
+    {$project: {_id: 0, indexName: "$$ROOT._id", inconsistentProperties: 1, missingFromShards: 1}}
+];
+
+const result = db.getSiblingDB("$DB_NAME").getCollection("$COLLECTION").aggregate(pipeline);
+
+print("\n📊 Index Inconsistency Report:");
+print("================================\n");
+
+let found = false;
+result.forEach(doc => {
+    found = true;
+    print("Index: " + doc.indexName);
+    if (doc.missingFromShards && doc.missingFromShards.length > 0) {
+        print("  ⚠️  Missing from shards: " + doc.missingFromShards.join(", "));
+    }
+    if (doc.inconsistentProperties && doc.inconsistentProperties.length > 0) {
+        print("  ⚠️  Inconsistent properties detected");
+    }
+    print("");
+});
+
+if (!found) {
+    print("✅ No index inconsistencies found - all indexes are consistent across shards\n");
+}
+EOJS
+
+# Replace variables in the JavaScript file
+sed -i '' "s/\$DB_NAME/$DB_NAME/g" "$TEMP_JS"
+sed -i '' "s/\$COLLECTION/$COLLECTION/g" "$TEMP_JS"
+
+# Execute the aggregation
+mongosh --quiet --file "$TEMP_JS"
+
+# Cleanup
+rm "$TEMP_JS"
+
+echo ""
+echo "📊 Checking shard distribution..."
+mongosh --quiet --eval "
+db.getSiblingDB('$DB_NAME').getCollection('$COLLECTION').aggregate([
+    {\$collStats:{}},
+    {\$group: {_id: '\$ns', shard_list: {\$addToSet: '\$shard'}}}
+]).forEach(doc => {
+    print('Collection: ' + doc._id);
+    print('Shards: ' + doc.shard_list.join(', '));
+});
+"
+
+echo ""
+echo "📋 Best practices from Context7 (/mongodb/docs):"
+echo "  ✓ Compound indexes should match query filter order"
+echo "  ✓ Use \$indexStats to detect inconsistencies in sharded collections"
+echo "  ✓ Verify indexes exist on all shards for sharded collections"
+echo "  ✓ Use aggregation pipelines for complex queries"
+echo "  ✓ Monitor index usage with explain('executionStats')"
+echo "  ✓ Create indexes on frequently queried fields"
+echo "  ✓ Avoid creating too many indexes (impacts write performance)"
+
+echo ""
+echo "✅ MongoDB shard check complete"

package/packages/plugin-databases/scripts/examples/postgres-index-analyze.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+# PostgreSQL index analysis and optimization
+# Usage: ./postgres-index-analyze.sh [database-name]
+
+set -euo pipefail
+
+DB_NAME="${1:-postgres}"
+
+echo "🔍 Analyzing PostgreSQL indexes for database: $DB_NAME"
+
+# Check for unused indexes
+echo ""
+echo "📊 Checking for unused indexes..."
+psql -d "$DB_NAME" -c "
+SELECT
+    schemaname,
+    tablename,
+    indexname,
+    idx_scan as scans,
+    pg_size_pretty(pg_relation_size(indexrelid)) as size
+FROM pg_stat_user_indexes
+WHERE idx_scan = 0 AND schemaname = 'public'
+ORDER BY pg_relation_size(indexrelid) DESC
+LIMIT 10;
+"
+
+# Check index hit ratio
+echo ""
+echo "📈 Checking index hit ratio..."
+psql -d "$DB_NAME" -c "
+SELECT
+    sum(idx_blks_hit) - sum(idx_blks_read) as idx_hit,
+    sum(idx_blks_hit) + sum(idx_blks_read) as idx_read,
+    CASE WHEN (sum(idx_blks_hit) + sum(idx_blks_read)) = 0 THEN 0
+         ELSE round(100.0 * sum(idx_blks_hit) / (sum(idx_blks_hit) + sum(idx_blks_read)), 2)
+    END as hit_ratio
+FROM pg_statio_user_indexes;
+"
+
+# Show largest tables without indexes
+echo ""
+echo "⚠️  Large tables without indexes..."
+psql -d "$DB_NAME" -c "
+SELECT
+    schemaname,
+    tablename,
+    pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as total_size,
+    n_tup_ins + n_tup_upd + n_tup_del as modifications
+FROM pg_stat_user_tables
+WHERE schemaname = 'public'
+  AND tablename NOT IN (
+    SELECT DISTINCT tablename
+    FROM pg_indexes
+    WHERE schemaname = 'public'
+  )
+ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC
+LIMIT 10;
+"
+
+# Check for missing indexes on foreign keys
+echo ""
+echo "🔑 Checking for missing indexes on foreign keys..."
+psql -d "$DB_NAME" -c "
+SELECT
+    tc.table_schema,
+    tc.table_name,
+    kcu.column_name,
+    pg_size_pretty(pg_total_relation_size(tc.table_schema||'.'||tc.table_name)) as table_size
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND NOT EXISTS (
+    SELECT 1
+    FROM pg_indexes
+    WHERE schemaname = tc.table_schema
+      AND tablename = tc.table_name
+      AND indexdef LIKE '%'||kcu.column_name||'%'
+  )
+ORDER BY pg_total_relation_size(tc.table_schema||'.'||tc.table_name) DESC
+LIMIT 10;
+"
+
+echo ""
+echo "📋 Best practices from Context7 (/websites/postgresql):"
+echo "  ✓ B-tree indexes for equality and range queries"
+echo "  ✓ Partial indexes for filtered queries (WHERE clause)"
+echo "  ✓ Covering indexes with INCLUDE clause (avoid heap lookups)"
+echo "  ✓ CREATE INDEX CONCURRENTLY to avoid table locks"
+echo "  ✓ Use EXPLAIN ANALYZE to verify index usage"
+echo "  ✓ Monitor pg_stat_user_indexes for index effectiveness"
+echo "  ✓ Drop unused indexes to reduce write overhead"
+
+echo ""
+echo "✅ PostgreSQL index analysis complete"

package/packages/plugin-databases/scripts/examples/redis-cache-stats.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# Redis cache statistics and performance analysis
+# Usage: ./redis-cache-stats.sh [host] [port]
+
+set -euo pipefail
+
+REDIS_HOST="${1:-localhost}"
+REDIS_PORT="${2:-6379}"
+
+echo "📊 Analyzing Redis cache performance..."
+echo "Host: $REDIS_HOST:$REDIS_PORT"
+
+# Check connection
+if ! redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" PING > /dev/null 2>&1; then
+    echo "❌ Cannot connect to Redis at $REDIS_HOST:$REDIS_PORT"
+    exit 1
+fi
+
+# Get memory stats
+echo ""
+echo "💾 Memory Statistics:"
+redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" INFO memory | grep -E "used_memory_human|used_memory_peak_human|mem_fragmentation_ratio|maxmemory_policy"
+
+# Get keyspace stats
+echo ""
+echo "🔑 Keyspace Statistics:"
+redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" INFO keyspace
+
+# Get hit/miss ratio
+echo ""
+echo "🎯 Cache Hit/Miss Ratio:"
+redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" INFO stats | grep -E "keyspace_hits|keyspace_misses" | while read -r line; do
+    echo "  $line"
+done
+
+# Calculate hit rate
+HITS=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" INFO stats | grep "keyspace_hits:" | cut -d: -f2 | tr -d '\r')
+MISSES=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" INFO stats | grep "keyspace_misses:" | cut -d: -f2 | tr -d '\r')
+
+if [ -n "$HITS" ] && [ -n "$MISSES" ]; then
+    TOTAL=$((HITS + MISSES))
+    if [ "$TOTAL" -gt 0 ]; then
+        HIT_RATE=$(awk "BEGIN {printf \"%.2f\", ($HITS / $TOTAL) * 100}")
+        echo "  Hit Rate: $HIT_RATE%"
+
+        if (( $(echo "$HIT_RATE < 80" | bc -l) )); then
+            echo "  ⚠️  Hit rate below 80% - consider reviewing cache strategy"
+        else
+            echo "  ✅ Hit rate is healthy (>80%)"
+        fi
+    fi
+fi
+
+# Check persistence configuration
+echo ""
+echo "💿 Persistence Configuration:"
+redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" CONFIG GET save | tail -1
+redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" CONFIG GET appendonly | tail -1
+
+# Check for slow log entries
+echo ""
+echo "🐌 Recent Slow Log Entries:"
+SLOW_COUNT=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" SLOWLOG LEN)
+if [ "$SLOW_COUNT" -gt 0 ]; then
+    echo "  Found $SLOW_COUNT slow log entries"
+    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" SLOWLOG GET 5
+else
+    echo "  ✅ No slow log entries"
+fi
+
+# Check connected clients
+echo ""
+echo "👥 Connected Clients:"
+redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" INFO clients | grep "connected_clients:"
+
+# Sample key distribution by data type
+echo ""
+echo "📦 Key Distribution by Type:"
+for type in string list set zset hash stream; do
+    count=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" --scan --pattern "*" | \
+            xargs -I{} redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" TYPE {} | \
+            grep -c "^$type$" || echo "0")
+    if [ "$count" -gt 0 ]; then
+        echo "  $type: $count"
+    fi
+done
+
+echo ""
+echo "📋 Best practices from Context7 (/websites/redis_io):"
+echo "  ✓ Client-side caching with placeholder pattern for race condition prevention"
+echo "  ✓ Use appropriate data structures:"
+echo "    - Hash: For objects with multiple fields"
+echo "    - Set: For unique collections, membership tests"
+echo "    - Sorted Set: For ranked/scored data, leaderboards"
+echo "    - List: For queues, stacks, recent items"
+echo "    - String: For simple key-value, counters"
+echo "  ✓ Configure persistence: AOF for durability, RDB for snapshots"
+echo "  ✓ Set expiration (TTL) on cached items"
+echo "  ✓ Monitor memory usage and implement eviction policies"
+echo "  ✓ Use pipelining for multiple commands"
+echo "  ✓ Avoid KEYS in production (use SCAN instead)"
+echo "  ✓ Target cache hit rate > 80%"
+
+echo ""
+echo "💡 Cache Strategy Recommendations:"
+if [ -n "$HIT_RATE" ]; then
+    if (( $(echo "$HIT_RATE < 80" | bc -l) )); then
+        echo "  1. Review TTL settings - may be too short"
+        echo "  2. Analyze cache miss patterns"
+        echo "  3. Consider warming cache on startup"
+        echo "  4. Implement write-through caching where appropriate"
+    fi
+fi
+
+MEMORY_POLICY=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" CONFIG GET maxmemory-policy | tail -1)
+if [ "$MEMORY_POLICY" = "noeviction" ]; then
+    echo "  ⚠️  Eviction policy is 'noeviction' - consider using LRU or LFU"
+fi
+
+echo ""
+echo "✅ Redis cache analysis complete"