claude-flow-novice 2.18.23 → 2.18.25

package/config/prometheus.yml

@@ -0,0 +1,85 @@
+# Prometheus Configuration for Hybrid AI Infrastructure
+# Version: 2.0.0
+
+global:
+  scrape_interval: 15s
+  evaluation_interval: 15s
+  external_labels:
+    cluster: 'hybrid-ai-infrastructure'
+    environment: 'production'
+
+# Alertmanager configuration (optional)
+alerting:
+  alertmanagers:
+    - static_configs:
+        - targets: []
+          # - alertmanager:9093
+
+# Rule files (optional)
+rule_files:
+  # - "alerts/*.yml"
+
+# Scrape configurations
+scrape_configs:
+  # Prometheus self-monitoring
+  - job_name: 'prometheus'
+    static_configs:
+      - targets: ['localhost:9090']
+        labels:
+          service: 'prometheus'
+
+  # Redis monitoring
+  - job_name: 'redis'
+    static_configs:
+      - targets: ['redis:6379']
+        labels:
+          service: 'redis'
+          role: 'coordination'
+
+  # PostgreSQL monitoring (requires postgres_exporter)
+  - job_name: 'postgresql'
+    static_configs:
+      - targets: ['postgresql:5432']
+        labels:
+          service: 'postgresql'
+          role: 'storage'
+
+  # Grafana monitoring
+  - job_name: 'grafana'
+    static_configs:
+      - targets: ['grafana:3000']
+        labels:
+          service: 'grafana'
+          role: 'visualization'
+
+  # Coordinator monitoring (requires agent health endpoints)
+  - job_name: 'coordinators'
+    scrape_interval: 30s
+    static_configs:
+      - targets:
+          - 'coordinator_marketing:8080'
+          - 'coordinator_engineering:8080'
+          - 'coordinator_sales:8080'
+          - 'coordinator_support:8080'
+          - 'coordinator_finance:8080'
+        labels:
+          role: 'coordinator'
+          provider: 'claude-max'
+
+  # Worker monitoring (dynamic service discovery recommended for production)
+  - job_name: 'workers'
+    scrape_interval: 60s
+    dns_sd_configs:
+      - names:
+          - 'worker.hybrid_network'
+        type: 'A'
+        port: 8080
+    relabel_configs:
+      - source_labels: [__meta_dns_name]
+        target_label: instance
+      - source_labels: []
+        target_label: role
+        replacement: 'worker'
+      - source_labels: []
+        target_label: provider
+        replacement: 'z-ai'

package/config/promtail/promtail-config.yml

@@ -0,0 +1,162 @@
+# Promtail Configuration
+# Task P2-2.3: Centralized Logging with ELK/Loki Stack
+# Version: 2.9.0
+#
+# Promtail is an agent which ships the contents of local logs to a private Loki instance
+# or Grafana Cloud. It is usually deployed to every machine that has applications which
+# need to be monitored.
+
+server:
+  http_listen_port: 9080
+  grpc_listen_port: 0
+  log_level: info
+  log_format: json
+
+positions:
+  filename: /tmp/positions.yaml
+  sync_period: 10s
+  sync_interval: 10s
+
+scrape_configs:
+  # Scrape logs from systemd journal
+  - job_name: journal
+    journal:
+      max_age: 24h
+      labels:
+        job: systemd-journal
+        source: journal
+    relabel_configs:
+      - source_labels: ['__journal__systemd_unit']
+        target_label: 'unit'
+      - source_labels: ['__journal_hostname']
+        target_label: 'hostname'
+      - source_labels: ['__journal_priority']
+        target_label: 'severity'
+
+  # Scrape Docker container logs
+  - job_name: docker
+    docker:
+      host: unix:///var/run/docker.sock
+      labels:
+        job: docker-containers
+        source: docker
+    relabel_configs:
+      - source_labels: ['__meta_docker_container_name']
+        target_label: 'container_name'
+      - source_labels: ['__meta_docker_container_id']
+        target_label: 'container_id'
+      - source_labels: ['__meta_docker_container_image_name']
+        target_label: 'image_name'
+      - source_labels: ['__meta_docker_container_network_mode']
+        target_label: 'network_mode'
+      - source_labels: ['__meta_docker_container_log_stream']
+        target_label: 'stream'
+
+  # Scrape application logs from /var/log
+  - job_name: varlog
+    static_configs:
+      - targets:
+          - localhost
+        labels:
+          job: varlogs
+          source: filesystem
+    pipeline_stages:
+      - multiline:
+          line_start_pattern: '^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}'
+      - json:
+          expressions:
+            timestamp: timestamp
+            level: level
+            message: message
+            context: context
+            correlationId: correlationId
+            taskId: taskId
+            agentId: agentId
+            traceId: traceId
+          on_error: keep
+      - labels:
+          timestamp: ''
+          level: ''
+          message: ''
+          context: ''
+          correlationId: ''
+          taskId: ''
+          agentId: ''
+          traceId: ''
+      - drop:
+          expression: '.*TLS.*'
+          on_error: keep
+    file_sd_configs:
+      - files:
+          - /var/log/cfn/**/*.log
+        refresh_interval: 30s
+
+  # Scrape CFN-specific logs
+  - job_name: cfn-logs
+    static_configs:
+      - targets:
+          - localhost
+        labels:
+          job: cfn-application
+          source: cfn
+    pipeline_stages:
+      - multiline:
+          line_start_pattern: '^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}'
+      - json:
+          expressions:
+            timestamp: timestamp
+            level: level
+            message: message
+            context: context
+            correlationId: correlationId
+            taskId: taskId
+            agentId: agentId
+          on_error: keep
+      - labels:
+          timestamp: ''
+          level: ''
+          message: ''
+          context: ''
+          correlationId: ''
+          taskId: ''
+          agentId: ''
+      - timestamp:
+          format: RFC3339Nano
+          source: timestamp
+          on_error: keep
+      - output:
+          source: message
+    file_sd_configs:
+      - files:
+          - /var/log/cfn/*.log
+        refresh_interval: 30s
+
+clients:
+  - url: http://loki:3100/loki/api/v1/push
+    batchwait: 1s
+    batchsize: 1048576  # 1MB batch size
+    backoff_config:
+      min_backoff: 100ms
+      max_backoff: 10s
+      max_retries: 3
+    timeout: 10s
+    external_labels:
+      environment: production
+      cluster: cfn
+
+# Limits configuration
+limits_config:
+  # Maximum size of a log entry
+  max_entry_limit_bytes: 262144  # 256KB
+  # Maximum number of log entries per second
+  max_streams: 1000
+  max_global_streams_matched_per_user: 10000
+
+# Target discovery settings
+target_config:
+  # How often to sync targets
+  sync_period: 10s
+
+# Tracing (optional)
+# tracing:
+#   enabled: false

package/config/redis.conf

@@ -0,0 +1,33 @@
+# Redis Production Configuration
+
+# Network
+bind 0.0.0.0
+port 6379
+protected-mode no
+
+# General
+daemonize no
+pidfile /var/run/redis_6379.pid
+loglevel notice
+logfile ""
+
+# Snapshotting
+save 900 1
+save 300 10
+save 60 10000
+
+# Memory
+maxmemory 256mb
+maxmemory-policy allkeys-lru
+
+# Persistence
+appendonly yes
+appendfsync everysec
+
+# Performance
+tcp-keepalive 300
+timeout 0
+
+# Client connections
+tcp-backlog 511
+databases 16

package/config/redis.config.js

@@ -0,0 +1,115 @@
+// Redis Configuration
+
+const { createClient } = require('redis');
+
+const redisConfig = {
+  // Primary connection settings
+  primary: {
+    url: process.env.REDIS_URL || 'redis://localhost:6379',
+    username: process.env.REDIS_USERNAME || '',
+    password: process.env.REDIS_PASSWORD || '',
+
+    // Connection options
+    connectionOptions: {
+      // Connection timeout in milliseconds
+      connectTimeout: 5000,
+
+      // Retry strategy for connection failures
+      retryStrategy: (retries) => {
+        if (retries > 3) {
+          console.error('Max Redis connection retries exceeded');
+          return new Error('Redis connection failed');
+        }
+        // Exponential backoff
+        return Math.min(retries * 100, 3000);
+      },
+
+      // Socket connection settings
+      socket: {
+        keepAlive: true,
+        connectTimeout: 5000,
+        reconnectStrategy: (retries) => {
+          if (retries > 3) return new Error('Max reconnect attempts');
+          return Math.min(retries * 100, 3000);
+        }
+      }
+    },
+
+    // Logging configuration
+    logging: {
+      enabled: process.env.REDIS_LOGGING === 'true' || false,
+      level: process.env.REDIS_LOG_LEVEL || 'error'
+    }
+  },
+
+  // Backup/Fallback Redis configurations
+  fallback: [
+    {
+      url: process.env.REDIS_FALLBACK_1 || '',
+      username: process.env.REDIS_FALLBACK_USERNAME_1 || '',
+      password: process.env.REDIS_FALLBACK_PASSWORD_1 || ''
+    }
+  ],
+
+  // Redis availability check configuration
+  healthCheck: {
+    interval: 30000, // Check every 30 seconds
+    timeout: 5000,   // 5-second timeout for health checks
+    retries: 3       // Number of retries before marking unavailable
+  },
+
+  // Optional advanced configurations
+  advanced: {
+    clusterMode: process.env.REDIS_CLUSTER_MODE === 'true' || false,
+    sentinelMode: process.env.REDIS_SENTINEL_MODE === 'true' || false
+  }
+};
+
+// Async Redis client creation with comprehensive error handling
+async function createRedisClient(config = redisConfig.primary) {
+  try {
+    const client = createClient({
+      url: config.url,
+      username: config.username,
+      password: config.password,
+      ...config.connectionOptions
+    });
+
+    // Event handlers for robust connection management
+    client.on('error', (err) => {
+      console.error('Redis Client Error:', err);
+    });
+
+    client.on('connect', () => {
+      console.log('Redis client connected successfully');
+    });
+
+    client.on('reconnecting', () => {
+      console.log('Redis client attempting to reconnect');
+    });
+
+    await client.connect();
+
+    return client;
+  } catch (error) {
+    console.error('Failed to create Redis client:', error);
+    throw error;
+  }
+}
+
+// Redis availability check
+async function checkRedisAvailability(client) {
+  try {
+    await client.ping();
+    return true;
+  } catch (error) {
+    console.error('Redis availability check failed:', error);
+    return false;
+  }
+}
+
+module.exports = {
+  redisConfig,
+  createRedisClient,
+  checkRedisAvailability
+};