@cubis/foundry 0.3.10

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/monitoring-expert/references/application-profiling.md

@@ -0,0 +1,331 @@
+# Application Profiling
+
+## Node.js Profiling
+
+### CPU Profiling with clinic.js
+
+```bash
+# Install
+npm install -g clinic
+
+# CPU profiling
+clinic doctor -- node app.js
+
+# Flame graph
+clinic flame -- node app.js
+
+# Bubble profiling
+clinic bubbleprof -- node app.js
+
+# Generate report
+clinic doctor --collect-only -- node app.js
+clinic doctor --visualize-only PID.clinic-doctor
+```
+
+### Built-in Node.js Profiler
+
+```javascript
+// Start profiling
+node --prof app.js
+
+# Process the output
+node --prof-process isolate-0x*.log > processed.txt
+
+# Chrome DevTools
+node --inspect app.js
+# Open chrome://inspect
+```
+
+### Memory Profiling
+
+```javascript
+import v8 from 'v8';
+import fs from 'fs';
+
+// Heap snapshot
+const snapshot = v8.writeHeapSnapshot();
+console.log('Snapshot written to:', snapshot);
+
+// Memory usage
+const usage = process.memoryUsage();
+console.log({
+  rss: `${Math.round(usage.rss / 1024 / 1024)}MB`,
+  heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)}MB`,
+  heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)}MB`,
+  external: `${Math.round(usage.external / 1024 / 1024)}MB`,
+});
+```
+
+### Custom Performance Marks
+
+```javascript
+import { performance, PerformanceObserver } from 'perf_hooks';
+
+// Mark start
+performance.mark('operation-start');
+
+// ... do work ...
+await processOrder(orderId);
+
+// Mark end
+performance.mark('operation-end');
+
+// Measure
+performance.measure('operation', 'operation-start', 'operation-end');
+
+// Observer
+const obs = new PerformanceObserver((items) => {
+  items.getEntries().forEach((entry) => {
+    console.log(`${entry.name}: ${entry.duration}ms`);
+  });
+});
+obs.observe({ entryTypes: ['measure'] });
+```
+
+## Python Profiling
+
+### cProfile
+
+```python
+import cProfile
+import pstats
+
+# Profile a function
+def main():
+    # Your code here
+    process_data()
+
+if __name__ == '__main__':
+    profiler = cProfile.Profile()
+    profiler.enable()
+
+    main()
+
+    profiler.disable()
+    stats = pstats.Stats(profiler)
+    stats.sort_stats('cumulative')
+    stats.print_stats(20)  # Top 20 functions
+```
+
+### Line Profiler
+
+```python
+from line_profiler import LineProfiler
+
+@profile
+def expensive_function():
+    # Code to profile
+    result = []
+    for i in range(10000):
+        result.append(i ** 2)
+    return result
+
+# Run with: kernprof -l -v script.py
+```
+
+### Memory Profiler
+
+```python
+from memory_profiler import profile
+
+@profile
+def process_large_data():
+    data = [i for i in range(1000000)]
+    result = [x * 2 for x in data]
+    return result
+
+# Run with: python -m memory_profiler script.py
+```
+
+### py-spy
+
+```bash
+# CPU sampling (live process)
+py-spy top --pid 12345
+
+# Generate flame graph
+py-spy record -o profile.svg --pid 12345
+
+# Record for duration
+py-spy record -o profile.svg --duration 60 -- python app.py
+```
+
+## Go Profiling
+
+### pprof
+
+```go
+import (
+    "net/http"
+    _ "net/http/pprof"
+    "runtime"
+)
+
+func main() {
+    // Enable profiling endpoint
+    go func() {
+        http.ListenAndServe("localhost:6060", nil)
+    }()
+
+    // Your application code
+}
+```
+
+```bash
+# CPU profile
+curl http://localhost:6060/debug/pprof/profile?seconds=30 > cpu.prof
+go tool pprof cpu.prof
+
+# Memory profile
+curl http://localhost:6060/debug/pprof/heap > heap.prof
+go tool pprof heap.prof
+
+# Goroutine profile
+curl http://localhost:6060/debug/pprof/goroutine > goroutine.prof
+go tool pprof goroutine.prof
+
+# Web interface
+go tool pprof -http=:8080 cpu.prof
+```
+
+## Java Profiling
+
+### VisualVM
+
+```bash
+# Start application with JMX
+java -Dcom.sun.management.jmxremote \
+     -Dcom.sun.management.jmxremote.port=9010 \
+     -Dcom.sun.management.jmxremote.authenticate=false \
+     -Dcom.sun.management.jmxremote.ssl=false \
+     -jar app.jar
+
+# Connect with VisualVM
+jvisualvm
+```
+
+### async-profiler
+
+```bash
+# CPU profiling
+./profiler.sh -d 30 -f cpu.html <pid>
+
+# Allocation profiling
+./profiler.sh -d 30 -e alloc -f alloc.html <pid>
+
+# Flame graph
+./profiler.sh -d 30 -f flamegraph.svg <pid>
+```
+
+## Database Query Profiling
+
+### PostgreSQL
+
+```sql
+-- Enable query logging
+ALTER SYSTEM SET log_min_duration_statement = 100;  -- Log queries > 100ms
+SELECT pg_reload_conf();
+
+-- Explain analyze
+EXPLAIN ANALYZE
+SELECT * FROM orders
+WHERE user_id = 123
+AND created_at > NOW() - INTERVAL '30 days';
+
+-- Track slow queries
+SELECT query, calls, total_time, mean_time
+FROM pg_stat_statements
+ORDER BY mean_time DESC
+LIMIT 10;
+```
+
+### MySQL
+
+```sql
+-- Enable slow query log
+SET GLOBAL slow_query_log = 'ON';
+SET GLOBAL long_query_time = 0.1;  -- 100ms
+
+-- Explain query
+EXPLAIN ANALYZE
+SELECT * FROM orders
+WHERE user_id = 123;
+
+-- Performance schema
+SELECT * FROM performance_schema.events_statements_summary_by_digest
+ORDER BY SUM_TIMER_WAIT DESC
+LIMIT 10;
+```
+
+## APM Integration
+
+### New Relic
+
+```javascript
+import newrelic from 'newrelic';
+
+// Custom transaction
+newrelic.startBackgroundTransaction('process-orders', async () => {
+  const orders = await getOrders();
+
+  // Custom segment
+  await newrelic.startSegment('validate-orders', true, async () => {
+    return validateOrders(orders);
+  });
+});
+
+// Custom metrics
+newrelic.recordMetric('Custom/OrderValue', orderTotal);
+```
+
+### DataDog APM
+
+```javascript
+import tracer from 'dd-trace';
+tracer.init();
+
+// Custom span
+const span = tracer.startSpan('process.order', {
+  resource: orderId,
+  tags: {
+    'order.total': orderTotal,
+    'user.id': userId,
+  },
+});
+
+try {
+  await processOrder(orderId);
+  span.setTag('status', 'success');
+} catch (err) {
+  span.setTag('error', err);
+} finally {
+  span.finish();
+}
+```
+
+## Quick Reference
+
+| Tool | Language | Type |
+|------|----------|------|
+| clinic.js | Node.js | CPU, Event loop |
+| Chrome DevTools | Node.js | CPU, Memory |
+| cProfile | Python | CPU |
+| py-spy | Python | CPU (sampling) |
+| pprof | Go | CPU, Memory, Goroutines |
+| VisualVM | Java | CPU, Memory, Threads |
+| async-profiler | Java | CPU, Allocation |
+
+| Metric | What to Look For |
+|--------|------------------|
+| CPU time | Hot functions, tight loops |
+| Memory | Large allocations, leaks |
+| I/O wait | Blocking operations |
+| GC time | Excessive collections |
+| Thread count | Thread pool saturation |
+
+| Problem | Symptom |
+|---------|---------|
+| CPU bound | High CPU usage, slow processing |
+| Memory leak | Growing memory, eventual crash |
+| I/O bound | Low CPU, high wait time |
+| Lock contention | Idle threads, poor scaling |

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/monitoring-expert/references/capacity-planning.md

@@ -0,0 +1,344 @@
+# Capacity Planning
+
+## Growth Projection
+
+### Linear Projection
+
+```python
+import pandas as pd
+import numpy as np
+from sklearn.linear_model import LinearRegression
+
+# Historical data
+data = pd.DataFrame({
+    'month': range(1, 13),
+    'requests_per_second': [100, 120, 145, 160, 180, 200, 220, 245, 270, 290, 310, 330]
+})
+
+# Train model
+model = LinearRegression()
+X = data[['month']].values
+y = data['requests_per_second'].values
+model.fit(X, y)
+
+# Forecast next 6 months
+future_months = np.array([[13], [14], [15], [16], [17], [18]])
+predictions = model.predict(future_months)
+
+print("Projected RPS in 6 months:", predictions[-1])
+```
+
+### Prometheus Queries for Trends
+
+```promql
+# Monthly growth rate
+(
+  rate(http_requests_total[30d])
+  /
+  rate(http_requests_total[30d] offset 30d)
+) - 1
+
+# Predict resource exhaustion
+predict_linear(
+  node_memory_MemAvailable_bytes[1h],
+  3600 * 24 * 30  # 30 days ahead
+)
+
+# Storage growth
+predict_linear(
+  node_filesystem_avail_bytes[7d],
+  3600 * 24 * 90  # 90 days ahead
+)
+```
+
+## Resource Forecasting
+
+### CPU Requirements
+
+```javascript
+// Current capacity
+const currentRPS = 1000;
+const currentCPU = 0.65;  // 65% utilization
+const targetCPU = 0.70;   // Target 70% max
+
+// Projected load
+const projectedRPS = 2500;
+
+// Required CPU capacity
+const cpuScalingFactor = projectedRPS / currentRPS;
+const requiredCPU = (currentCPU * cpuScalingFactor) / targetCPU;
+
+console.log(`Current: ${currentRPS} RPS @ ${currentCPU * 100}% CPU`);
+console.log(`Projected: ${projectedRPS} RPS requires ${requiredCPU.toFixed(2)}x CPU`);
+```
+
+### Memory Requirements
+
+```javascript
+// Memory per request (average)
+const avgMemoryPerRequest = 2048;  // bytes
+const concurrentRequests = 500;
+const overhead = 1.3;  // 30% overhead for GC, OS, etc.
+
+const requiredMemory = (avgMemoryPerRequest * concurrentRequests * overhead) / (1024 ** 3);
+console.log(`Required memory: ${requiredMemory.toFixed(2)} GB`);
+```
+
+### Database Connections
+
+```javascript
+// Connections per instance
+const connectionsPerInstance = 100;
+const instances = 5;
+const utilizationTarget = 0.75;
+
+// Available connections
+const totalConnections = connectionsPerInstance * instances;
+const effectiveConnections = totalConnections * utilizationTarget;
+
+// RPS capacity
+const avgRequestsPerConnection = 10;
+const maxRPS = effectiveConnections * avgRequestsPerConnection;
+
+console.log(`Max sustainable RPS: ${maxRPS}`);
+```
+
+## Scaling Strategies
+
+### Horizontal Scaling Calculator
+
+```javascript
+function calculateInstances(targetRPS, instanceCapacity, bufferPercent = 20) {
+  // Account for buffer
+  const effectiveCapacity = instanceCapacity * (1 - bufferPercent / 100);
+
+  // Calculate required instances
+  const requiredInstances = Math.ceil(targetRPS / effectiveCapacity);
+
+  // Account for availability zones
+  const minInstancesPerAZ = 2;
+  const zones = 3;
+  const minTotal = minInstancesPerAZ * zones;
+
+  return Math.max(requiredInstances, minTotal);
+}
+
+console.log(calculateInstances(5000, 1000));  // 7 instances
+```
+
+### Auto-scaling Configuration
+
+```yaml
+# Kubernetes HPA
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: app-hpa
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: app
+  minReplicas: 3
+  maxReplicas: 20
+  metrics:
+    - type: Resource
+      resource:
+        name: cpu
+        target:
+          type: Utilization
+          averageUtilization: 70
+    - type: Resource
+      resource:
+        name: memory
+        target:
+          type: Utilization
+          averageUtilization: 80
+    - type: Pods
+      pods:
+        metric:
+          name: http_requests_per_second
+        target:
+          type: AverageValue
+          averageValue: "1000"
+  behavior:
+    scaleDown:
+      stabilizationWindowSeconds: 300
+      policies:
+        - type: Percent
+          value: 50
+          periodSeconds: 60
+    scaleUp:
+      stabilizationWindowSeconds: 0
+      policies:
+        - type: Percent
+          value: 100
+          periodSeconds: 30
+        - type: Pods
+          value: 4
+          periodSeconds: 30
+      selectPolicy: Max
+```
+
+### AWS Auto Scaling
+
+```json
+{
+  "AutoScalingGroupName": "app-asg",
+  "MinSize": 3,
+  "MaxSize": 20,
+  "DesiredCapacity": 5,
+  "TargetTrackingScalingPolicies": [
+    {
+      "TargetValue": 70.0,
+      "PredefinedMetricSpecification": {
+        "PredefinedMetricType": "ASGAverageCPUUtilization"
+      },
+      "ScaleInCooldown": 300,
+      "ScaleOutCooldown": 60
+    },
+    {
+      "TargetValue": 1000.0,
+      "CustomizedMetricSpecification": {
+        "MetricName": "RequestCountPerTarget",
+        "Namespace": "AWS/ApplicationELB",
+        "Statistic": "Sum"
+      }
+    }
+  ]
+}
+```
+
+## Performance Budgets
+
+### Response Time Budget
+
+```javascript
+const performanceBudget = {
+  // Page load budgets
+  ttfb: 200,          // Time to First Byte (ms)
+  fcp: 1000,          // First Contentful Paint (ms)
+  lcp: 2500,          // Largest Contentful Paint (ms)
+
+  // API budgets
+  apiP50: 100,        // 50th percentile (ms)
+  apiP95: 500,        // 95th percentile (ms)
+  apiP99: 1000,       // 99th percentile (ms)
+
+  // Resource budgets
+  jsBundle: 200,      // JavaScript bundle size (KB)
+  cssBundle: 50,      // CSS bundle size (KB)
+  images: 500,        // Total images (KB)
+
+  // Infrastructure budgets
+  cpuUtilization: 70,     // Max % during normal load
+  memoryUtilization: 80,  // Max % during normal load
+  errorRate: 0.01,        // Max 1% error rate
+};
+
+function checkBudget(actual, budget, metric) {
+  if (actual > budget) {
+    console.warn(`Budget exceeded for ${metric}: ${actual} > ${budget}`);
+    return false;
+  }
+  return true;
+}
+```
+
+## Cost Optimization
+
+### Instance Sizing
+
+```javascript
+function optimizeInstanceSize(workload) {
+  const instances = [
+    { type: 't3.small', vcpu: 2, memory: 2, cost: 0.0208 },
+    { type: 't3.medium', vcpu: 2, memory: 4, cost: 0.0416 },
+    { type: 't3.large', vcpu: 2, memory: 8, cost: 0.0832 },
+    { type: 'm5.large', vcpu: 2, memory: 8, cost: 0.096 },
+    { type: 'm5.xlarge', vcpu: 4, memory: 16, cost: 0.192 },
+  ];
+
+  const filtered = instances.filter(i =>
+    i.vcpu >= workload.requiredVCPU &&
+    i.memory >= workload.requiredMemory
+  );
+
+  // Sort by cost efficiency
+  return filtered.sort((a, b) => {
+    const scoreA = (a.vcpu * a.memory) / a.cost;
+    const scoreB = (b.vcpu * b.memory) / b.cost;
+    return scoreB - scoreA;
+  })[0];
+}
+
+const recommendation = optimizeInstanceSize({
+  requiredVCPU: 2,
+  requiredMemory: 4,
+});
+
+console.log('Recommended instance:', recommendation);
+```
+
+## Capacity Alerts
+
+```yaml
+# Prometheus alerting rules
+groups:
+  - name: capacity
+    rules:
+      - alert: HighCPUPrediction
+        expr: |
+          predict_linear(
+            node_cpu_seconds_total{mode="idle"}[1h],
+            3600 * 24 * 7  # 7 days ahead
+          ) < 0.2
+        for: 1h
+        annotations:
+          summary: CPU capacity will be exhausted in 7 days
+
+      - alert: DiskSpaceProjection
+        expr: |
+          predict_linear(
+            node_filesystem_avail_bytes[7d],
+            3600 * 24 * 30
+          ) < 1e9  # Less than 1GB in 30 days
+        annotations:
+          summary: Disk space will run out in 30 days
+
+      - alert: DatabaseConnectionsNearLimit
+        expr: |
+          pg_stat_database_numbackends / pg_settings_max_connections > 0.8
+        for: 10m
+        annotations:
+          summary: Database connections at 80% capacity
+
+      - alert: ScalingRecommendation
+        expr: |
+          rate(http_requests_total[5m]) >
+          (instance_capacity * instance_count * 0.7)
+        annotations:
+          summary: Consider scaling up - traffic approaching capacity
+```
+
+## Quick Reference
+
+| Metric | Buffer | Reasoning |
+|--------|--------|-----------|
+| CPU | 30% | Headroom for spikes |
+| Memory | 20% | GC and OS overhead |
+| Connections | 25% | Connection churn |
+| Storage | 40% | Growth + snapshots |
+
+| Planning Horizon | Update Frequency |
+|------------------|------------------|
+| 3 months | Weekly |
+| 6 months | Bi-weekly |
+| 12 months | Monthly |
+
+| Scaling Trigger | Action |
+|-----------------|--------|
+| 70% CPU | Start planning |
+| 80% CPU | Scale up |
+| 90% CPU | Emergency scaling |
+| 60% CPU for 24h | Scale down |