+ Showing {filteredAndSortedExperiments.length} of {experiments.length} experiments
+ {experiments.length >= 10000 && (
+
+ Large dataset - virtualized for performance
+
+ )}
+
+
+
+ {/* Experiments Table */}
+
+
+
+
+
+
+ );
+}
\ No newline at end of file
diff --git a/dashboard-v2/src/pages/NotFound.tsx b/dashboard-v2/src/pages/NotFound.tsx
new file mode 100644
index 0000000..ad96df7
--- /dev/null
+++ b/dashboard-v2/src/pages/NotFound.tsx
@@ -0,0 +1,17 @@
+import React from 'react';
+import { Link } from 'react-router-dom';
+
+export default function NotFound() {
+ return (
+
+
404
+
Page not found
+
+ Go to Dashboard
+
+
+ );
+}
\ No newline at end of file
diff --git a/dashboard-v2/src/pages/Settings.tsx b/dashboard-v2/src/pages/Settings.tsx
new file mode 100644
index 0000000..7fc7eea
--- /dev/null
+++ b/dashboard-v2/src/pages/Settings.tsx
@@ -0,0 +1,12 @@
+import React from 'react';
+
+export default function Settings() {
+ return (
+
+
Settings
+
+
Settings page coming soon...
+
+
+ );
+}
\ No newline at end of file
diff --git a/dashboard-v2/tailwind.config.js b/dashboard-v2/tailwind.config.js
new file mode 100644
index 0000000..d890c24
--- /dev/null
+++ b/dashboard-v2/tailwind.config.js
@@ -0,0 +1,41 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+ content: [
+ "./index.html",
+ "./src/**/*.{js,ts,jsx,tsx}",
+ ],
+ theme: {
+ extend: {
+ animation: {
+ 'fade-in': 'fadeIn 0.5s ease-in-out',
+ 'slide-up': 'slideUp 0.3s ease-out',
+ 'pulse-subtle': 'pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+ },
+ keyframes: {
+ fadeIn: {
+ '0%': { opacity: '0' },
+ '100%': { opacity: '1' },
+ },
+ slideUp: {
+ '0%': { transform: 'translateY(10px)', opacity: '0' },
+ '100%': { transform: 'translateY(0)', opacity: '1' },
+ },
+ },
+ colors: {
+ chaos: {
+ 50: '#f0f9ff',
+ 100: '#e0f2fe',
+ 200: '#bae6fd',
+ 300: '#7dd3fc',
+ 400: '#38bdf8',
+ 500: '#0ea5e9',
+ 600: '#0284c7',
+ 700: '#0369a1',
+ 800: '#075985',
+ 900: '#0c4a6e',
+ }
+ }
+ },
+ },
+ plugins: [],
+};
\ No newline at end of file
diff --git a/dashboard-v2/tsconfig.json b/dashboard-v2/tsconfig.json
new file mode 100644
index 0000000..f9a81ca
--- /dev/null
+++ b/dashboard-v2/tsconfig.json
@@ -0,0 +1,31 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "useDefineForClassFields": true,
+ "lib": ["ES2020", "DOM", "DOM.Iterable"],
+ "module": "ESNext",
+ "skipLibCheck": true,
+
+ /* Bundler mode */
+ "moduleResolution": "bundler",
+ "allowImportingTsExtensions": true,
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "noEmit": true,
+ "jsx": "react-jsx",
+
+ /* Linting */
+ "strict": true,
+ "noUnusedLocals": true,
+ "noUnusedParameters": true,
+ "noFallthroughCasesInSwitch": true,
+
+ /* Path mapping */
+ "baseUrl": ".",
+ "paths": {
+ "@/*": ["src/*"]
+ }
+ },
+ "include": ["src"],
+ "references": [{ "path": "./tsconfig.node.json" }]
+}
\ No newline at end of file
diff --git a/dashboard-v2/tsconfig.node.json b/dashboard-v2/tsconfig.node.json
new file mode 100644
index 0000000..099658c
--- /dev/null
+++ b/dashboard-v2/tsconfig.node.json
@@ -0,0 +1,10 @@
+{
+ "compilerOptions": {
+ "composite": true,
+ "skipLibCheck": true,
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "allowSyntheticDefaultImports": true
+ },
+ "include": ["vite.config.ts"]
+}
\ No newline at end of file
diff --git a/dashboard-v2/vite.config.ts b/dashboard-v2/vite.config.ts
new file mode 100644
index 0000000..ca7827d
--- /dev/null
+++ b/dashboard-v2/vite.config.ts
@@ -0,0 +1,77 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { VitePWA } from 'vite-plugin-pwa';
+
+export default defineConfig({
+ plugins: [
+ react(),
+ VitePWA({
+ registerType: 'autoUpdate',
+ workbox: {
+ globPatterns: ['**/*.{js,css,html,ico,png,svg}'],
+ runtimeCaching: [
+ {
+ urlPattern: /^https:\/\/api\./,
+ handler: 'NetworkFirst',
+ options: {
+ cacheName: 'api-cache',
+ expiration: {
+ maxEntries: 100,
+ maxAgeSeconds: 300 // 5 minutes
+ }
+ }
+ }
+ ]
+ },
+ manifest: {
+ name: 'ChaosLabs Dashboard',
+ short_name: 'ChaosLabs',
+ description: 'Chaos Engineering Dashboard with Audit Pack Viewer',
+ theme_color: '#1f2937',
+ background_color: '#ffffff',
+ display: 'standalone',
+ icons: [
+ {
+ src: '/icon-192.png',
+ sizes: '192x192',
+ type: 'image/png'
+ },
+ {
+ src: '/icon-512.png',
+ sizes: '512x512',
+ type: 'image/png'
+ }
+ ]
+ }
+ })
+ ],
+ build: {
+ rollupOptions: {
+ output: {
+ manualChunks: {
+ vendor: ['react', 'react-dom'],
+ query: ['@tanstack/react-query'],
+ virtual: ['@tanstack/react-virtual', 'react-window'],
+ charts: ['recharts'],
+ utils: ['date-fns', 'clsx']
+ }
+ }
+ },
+ target: 'esnext',
+ minify: 'esbuild',
+ sourcemap: true
+ },
+ optimizeDeps: {
+ include: ['react', 'react-dom', '@tanstack/react-query']
+ },
+ server: {
+ port: 3000,
+ proxy: {
+ '/api': {
+ target: 'http://localhost:8080',
+ changeOrigin: true,
+ rewrite: (path) => path.replace(/^\/api/, '')
+ }
+ }
+ }
+});
\ No newline at end of file
diff --git a/infrastructure/Dockerfile.controller.optimized b/infrastructure/Dockerfile.controller.optimized
new file mode 100644
index 0000000..9ed0540
--- /dev/null
+++ b/infrastructure/Dockerfile.controller.optimized
@@ -0,0 +1,125 @@
+# Multi-stage Docker build for optimized ChaosLab Controller
+# This Dockerfile implements best practices for build speed, security, and size optimization
+
+# Build cache stage - reused across builds for faster iterations
+FROM golang:1.21-alpine AS build-cache
+WORKDIR /build-cache
+# Install build dependencies and cache them
+RUN apk add --no-cache git ca-certificates tzdata make
+# Pre-download common Go modules to cache layer
+COPY go.mod go.sum ./
+RUN go mod download && go mod verify
+
+# Development stage - optimized for fast rebuilds during development
+FROM build-cache AS development
+WORKDIR /app
+# Copy source code
+COPY . .
+# Build with development flags for faster compilation
+RUN CGO_ENABLED=0 GOOS=linux go build \
+ -ldflags="-s -w" \
+ -gcflags="-N -l" \
+ -o controller-dev \
+ ./controller/
+
+# Test stage - runs tests and generates coverage
+FROM development AS test
+RUN go test -v -race -coverprofile=coverage.out ./controller/...
+RUN go tool cover -html=coverage.out -o coverage.html
+# Save test artifacts
+RUN mkdir -p /test-artifacts && \
+ cp coverage.out coverage.html /test-artifacts/
+
+# Security scanning stage
+FROM build-cache AS security-scan
+WORKDIR /app
+COPY . .
+# Install security tools
+RUN go install github.com/securecodewarrior/goat@latest || true
+RUN go install golang.org/x/vuln/cmd/govulncheck@latest || true
+# Run security checks (non-blocking for now)
+RUN govulncheck ./... || echo "Security scan completed with warnings"
+
+# Production build stage - optimized for smallest size and performance
+FROM build-cache AS production-build
+WORKDIR /app
+COPY . .
+
+# Build optimizations for production
+ENV CGO_ENABLED=0
+ENV GOOS=linux
+ENV GOARCH=amd64
+
+# Advanced build optimizations
+RUN go build \
+ -a \
+ -installsuffix cgo \
+ -ldflags="-s -w -X main.version=$(git describe --tags --always --dirty) -X main.buildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ) -extldflags '-static'" \
+ -tags netgo,osusergo \
+ -trimpath \
+ -mod=readonly \
+ -o controller \
+ ./controller/
+
+# Verify the binary
+RUN ./controller --version || echo "Version check completed"
+RUN file ./controller
+RUN ls -la ./controller
+
+# UPX compression stage (optional, can reduce binary size by 50-70%)
+FROM alpine:3.18 AS compress
+RUN apk add --no-cache upx
+WORKDIR /app
+COPY --from=production-build /app/controller .
+# Compress binary (optional - uncomment if size is critical)
+# RUN upx --best --lzma controller
+
+# Final production stage - minimal distroless image for security
+FROM gcr.io/distroless/static-debian11:nonroot AS production
+
+# Metadata labels
+LABEL maintainer="ChaosLabs Team "
+LABEL org.opencontainers.image.title="ChaosLabs Controller"
+LABEL org.opencontainers.image.description="High-performance chaos engineering controller with observability"
+LABEL org.opencontainers.image.source="https://github.com/your-org/chaoslabs"
+LABEL org.opencontainers.image.licenses="MIT"
+LABEL org.opencontainers.image.version="2.0"
+
+# Security: Run as non-root user
+USER nonroot:nonroot
+
+# Copy binary from build stage
+COPY --from=production-build --chown=nonroot:nonroot /app/controller /usr/local/bin/controller
+
+# Copy CA certificates for HTTPS requests
+COPY --from=production-build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
+
+# Add timezone data
+COPY --from=production-build /usr/share/zoneinfo /usr/share/zoneinfo
+
+# Expose ports
+EXPOSE 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+ CMD ["/usr/local/bin/controller", "--health-check"]
+
+# Entry point
+ENTRYPOINT ["/usr/local/bin/controller"]
+CMD ["--config=/etc/chaoslabs/config.yaml"]
+
+# Development variant - includes debugging tools
+FROM alpine:3.18 AS development-runtime
+RUN apk add --no-cache ca-certificates tzdata curl jq htop
+COPY --from=development /app/controller-dev /usr/local/bin/controller
+USER 1000:1000
+EXPOSE 8080 2345
+ENTRYPOINT ["/usr/local/bin/controller"]
+
+# Debug variant - includes delve debugger
+FROM golang:1.21-alpine AS debug
+RUN go install github.com/go-delve/delve/cmd/dlv@latest
+WORKDIR /app
+COPY --from=development /app .
+EXPOSE 8080 2345
+CMD ["dlv", "--listen=:2345", "--headless=true", "--api-version=2", "--accept-multiclient", "exec", "./controller-dev"]
\ No newline at end of file
diff --git a/infrastructure/cache-warming.sh b/infrastructure/cache-warming.sh
new file mode 100644
index 0000000..77f519b
--- /dev/null
+++ b/infrastructure/cache-warming.sh
@@ -0,0 +1,284 @@
+#!/bin/bash
+
+# Cache Warming Script for CI/CD Pipeline Optimization
+# This script pre-warms various caches to improve CI/CD performance
+
+set -e
+
+echo "🔥 Warming up caches for faster CI/CD..."
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+print_status() {
+ echo -e "${BLUE}[CACHE]${NC} $1"
+}
+
+print_success() {
+ echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+ echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Function to check if Docker is available
+check_docker() {
+ if ! command -v docker &> /dev/null; then
+ print_warning "Docker not found, skipping Docker cache warming"
+ return 1
+ fi
+ return 0
+}
+
+# Function to check if Go is available
+check_go() {
+ if ! command -v go &> /dev/null; then
+ print_warning "Go not found, skipping Go cache warming"
+ return 1
+ fi
+ return 0
+}
+
+# Function to check if Node.js is available
+check_node() {
+ if ! command -v npm &> /dev/null; then
+ print_warning "Node.js/npm not found, skipping Node cache warming"
+ return 1
+ fi
+ return 0
+}
+
+# Warm Go module cache
+warm_go_cache() {
+ if check_go; then
+ print_status "Warming Go module cache..."
+
+ # Download dependencies for all modules
+ for module in controller agent cli; do
+ if [ -f "$module/go.mod" ]; then
+ print_status "Downloading dependencies for $module..."
+ cd $module
+ go mod download
+ go mod verify
+ cd ..
+ fi
+ done
+
+ # Pre-compile standard library for common targets
+ print_status "Pre-compiling Go standard library..."
+ GOOS=linux GOARCH=amd64 go install -a std
+ GOOS=darwin GOARCH=amd64 go install -a std
+
+ # Install common development tools
+ print_status "Installing Go development tools..."
+ go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+ go install github.com/go-delve/delve/cmd/dlv@latest
+ go install golang.org/x/tools/cmd/goimports@latest
+ go install golang.org/x/vuln/cmd/govulncheck@latest
+
+ print_success "Go cache warmed successfully"
+ fi
+}
+
+# Warm Node.js cache
+warm_node_cache() {
+ if check_node; then
+ print_status "Warming Node.js cache..."
+
+ # Cache dashboard dependencies
+ if [ -f "dashboard-v2/package.json" ]; then
+ print_status "Caching dashboard dependencies..."
+ cd dashboard-v2
+ npm ci --prefer-offline --no-audit
+
+ # Pre-build commonly used packages
+ npm run build || print_warning "Dashboard build failed during cache warming"
+ cd ..
+ fi
+
+ # Cache documentation dependencies
+ if [ -f "docs/package.json" ]; then
+ print_status "Caching documentation dependencies..."
+ cd docs
+ npm ci --prefer-offline --no-audit
+ cd ..
+ fi
+
+ print_success "Node.js cache warmed successfully"
+ fi
+}
+
+# Warm Docker build cache
+warm_docker_cache() {
+ if check_docker; then
+ print_status "Warming Docker build cache..."
+
+ # Build base images with cache
+ print_status "Building Go build cache image..."
+ docker build \
+ --target build-cache \
+ --cache-from chaoslabs/controller:build-cache \
+ -t chaoslabs/controller:build-cache \
+ -f infrastructure/Dockerfile.controller.optimized \
+ .
+
+ # Build development images
+ print_status "Building development images..."
+ docker build \
+ --target development \
+ --cache-from chaoslabs/controller:build-cache \
+ --cache-from chaoslabs/controller:development \
+ -t chaoslabs/controller:development \
+ -f infrastructure/Dockerfile.controller.optimized \
+ .
+
+ # Pull commonly used base images
+ print_status "Pulling common base images..."
+ docker pull golang:1.21-alpine
+ docker pull node:18-alpine
+ docker pull alpine:3.18
+ docker pull gcr.io/distroless/static-debian11:nonroot
+ docker pull redis:7-alpine
+ docker pull nats:2.10-alpine
+ docker pull prom/prometheus:latest
+ docker pull grafana/grafana:latest
+
+ print_success "Docker cache warmed successfully"
+ fi
+}
+
+# Warm GitHub Actions cache
+warm_github_cache() {
+ print_status "Setting up GitHub Actions cache optimization..."
+
+ # Create cache key files for better cache hits
+ find . -name "go.mod" -o -name "go.sum" | sort | xargs cat | sha256sum > .github-cache-go.key
+ find . -name "package.json" -o -name "package-lock.json" | sort | xargs cat | sha256sum > .github-cache-node.key
+ find infrastructure/ -name "Dockerfile*" | sort | xargs cat | sha256sum > .github-cache-docker.key
+
+ print_success "GitHub Actions cache keys generated"
+}
+
+# Warm test data cache
+warm_test_cache() {
+ print_status "Warming test data cache..."
+
+ # Create test data directory
+ mkdir -p tests/cache
+
+ # Generate test data for performance tests
+ if check_go; then
+ print_status "Generating test data..."
+ go run tests/generate-test-data.go || print_warning "Test data generation failed"
+ fi
+
+ print_success "Test cache warmed successfully"
+}
+
+# Pre-compile frequently used tools
+warm_tools_cache() {
+ print_status "Pre-compiling development tools..."
+
+ if check_go; then
+ # Tools that are commonly used in CI/CD
+ tools=(
+ "github.com/golangci/golangci-lint/cmd/golangci-lint@latest"
+ "golang.org/x/vuln/cmd/govulncheck@latest"
+ "github.com/securecodewarrior/goat@latest"
+ "mvdan.cc/gofumpt@latest"
+ "golang.org/x/tools/cmd/goimports@latest"
+ )
+
+ for tool in "${tools[@]}"; do
+ tool_name=$(basename ${tool%@*})
+ if ! command -v $tool_name &> /dev/null; then
+ print_status "Installing $tool_name..."
+ go install $tool || print_warning "Failed to install $tool"
+ fi
+ done
+ fi
+
+ print_success "Tools cache warmed successfully"
+}
+
+# Generate performance benchmarks
+warm_benchmark_cache() {
+ print_status "Generating benchmark baselines..."
+
+ if check_go; then
+ # Run benchmarks to establish baselines
+ for module in controller agent cli; do
+ if [ -d "$module" ]; then
+ print_status "Running benchmarks for $module..."
+ cd $module
+ go test -bench=. -benchmem -count=3 > ../tests/benchmarks/$module-baseline.txt 2>/dev/null || true
+ cd ..
+ fi
+ done
+ fi
+
+ print_success "Benchmark cache warmed successfully"
+}
+
+# Main execution
+main() {
+ echo "🚀 Starting cache warming process..."
+ echo "This may take a few minutes but will significantly speed up future builds."
+ echo ""
+
+ # Create necessary directories
+ mkdir -p tests/cache
+ mkdir -p tests/benchmarks
+ mkdir -p .cache
+
+ # Run cache warming functions
+ warm_go_cache
+ warm_node_cache
+ warm_docker_cache
+ warm_github_cache
+ warm_test_cache
+ warm_tools_cache
+ warm_benchmark_cache
+
+ # Generate cache report
+ echo ""
+ print_success "Cache warming completed!"
+ echo ""
+ echo "📊 Cache Report:"
+ echo "================"
+
+ # Go cache size
+ if check_go; then
+ go_cache_size=$(du -sh $(go env GOCACHE) 2>/dev/null | cut -f1 || echo "Unknown")
+ go_mod_size=$(du -sh $(go env GOMODCACHE) 2>/dev/null | cut -f1 || echo "Unknown")
+ echo "Go build cache: $go_cache_size"
+ echo "Go module cache: $go_mod_size"
+ fi
+
+ # Node cache size
+ if check_node; then
+ npm_cache_size=$(du -sh ~/.npm 2>/dev/null | cut -f1 || echo "Unknown")
+ echo "npm cache: $npm_cache_size"
+ fi
+
+ # Docker cache size
+ if check_docker; then
+ docker_size=$(docker system df --format "table {{.Type}}\t{{.Size}}" | grep -E "Images|Build" | awk '{print $2}' | paste -sd+ | bc 2>/dev/null || echo "Unknown")
+ echo "Docker cache: ${docker_size}B"
+ fi
+
+ echo ""
+ echo "💡 Next time you run CI/CD or development builds, they should be significantly faster!"
+ echo ""
+ echo "🔧 To maintain optimal performance:"
+ echo " • Run this script monthly or when dependencies change significantly"
+ echo " • Use 'docker system prune' occasionally to clean up unused Docker cache"
+ echo " • Monitor cache sizes to ensure they don't grow too large"
+}
+
+# Run main function
+main "$@"
\ No newline at end of file
diff --git a/infrastructure/devtools/Dockerfile b/infrastructure/devtools/Dockerfile
new file mode 100644
index 0000000..3eac500
--- /dev/null
+++ b/infrastructure/devtools/Dockerfile
@@ -0,0 +1,129 @@
+# Development tools container with all necessary tools for ChaosLabs development
+FROM ubuntu:22.04
+
+LABEL maintainer="ChaosLabs DevOps "
+LABEL description="Development tools container for ChaosLabs"
+
+# Avoid prompts from apt
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install base packages
+RUN apt-get update && apt-get install -y \
+ curl \
+ wget \
+ git \
+ vim \
+ nano \
+ htop \
+ tree \
+ jq \
+ yq \
+ unzip \
+ zip \
+ ca-certificates \
+ gnupg \
+ lsb-release \
+ software-properties-common \
+ build-essential \
+ python3 \
+ python3-pip \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install Go
+ENV GO_VERSION=1.21.3
+RUN wget -O go.tar.gz "https://golang.org/dl/go${GO_VERSION}.linux-amd64.tar.gz" \
+ && tar -C /usr/local -xzf go.tar.gz \
+ && rm go.tar.gz
+ENV PATH="/usr/local/go/bin:${PATH}"
+ENV GOPATH="/go"
+ENV PATH="${GOPATH}/bin:${PATH}"
+
+# Install Node.js and npm
+ENV NODE_VERSION=18
+RUN curl -fsSL https://deb.nodesource.com/setup_${NODE_VERSION}.x | bash - \
+ && apt-get install -y nodejs
+
+# Install Docker CLI
+RUN curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg \
+ && echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null \
+ && apt-get update \
+ && apt-get install -y docker-ce-cli \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install docker-compose
+RUN pip3 install docker-compose
+
+# Install kubectl
+RUN curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" \
+ && install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl \
+ && rm kubectl
+
+# Install Helm
+RUN curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | tee /usr/share/keyrings/helm.gpg > /dev/null \
+ && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | tee /etc/apt/sources.list.d/helm-stable-debian.list \
+ && apt-get update \
+ && apt-get install -y helm \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install k6 for load testing
+RUN gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69 \
+ && echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | tee /etc/apt/sources.list.d/k6.list \
+ && apt-get update \
+ && apt-get install -y k6 \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install useful Go tools
+RUN go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest \
+ && go install github.com/go-delve/delve/cmd/dlv@latest \
+ && go install golang.org/x/tools/cmd/goimports@latest \
+ && go install github.com/securecodewarrior/goat@latest \
+ && go install golang.org/x/vuln/cmd/govulncheck@latest \
+ && go install github.com/air-verse/air@latest
+
+# Install development utilities
+RUN npm install -g \
+ typescript \
+ @typescript-eslint/parser \
+ @typescript-eslint/eslint-plugin \
+ prettier \
+ eslint \
+ nodemon \
+ concurrently
+
+# Install network debugging tools
+RUN apt-get update && apt-get install -y \
+ net-tools \
+ iputils-ping \
+ tcpdump \
+ nmap \
+ netcat \
+ telnet \
+ dig \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install monitoring tools
+RUN pip3 install \
+ httpie \
+ awscli \
+ ansible
+
+# Create workspace directory
+WORKDIR /workspace
+
+# Set up shell environment
+COPY bashrc /root/.bashrc
+COPY vimrc /root/.vimrc
+
+# Create useful aliases and functions
+RUN echo 'alias ll="ls -la"' >> /root/.bashrc \
+ && echo 'alias k="kubectl"' >> /root/.bashrc \
+ && echo 'alias dc="docker-compose"' >> /root/.bashrc \
+ && echo 'alias gr="go run"' >> /root/.bashrc \
+ && echo 'alias gt="go test"' >> /root/.bashrc \
+ && echo 'alias gl="golangci-lint run"' >> /root/.bashrc
+
+# Add development scripts
+COPY scripts/ /usr/local/bin/
+RUN chmod +x /usr/local/bin/*
+
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/infrastructure/devtools/scripts/dev-setup.sh b/infrastructure/devtools/scripts/dev-setup.sh
new file mode 100644
index 0000000..c16597a
--- /dev/null
+++ b/infrastructure/devtools/scripts/dev-setup.sh
@@ -0,0 +1,467 @@
+#!/bin/bash
+
+# ChaosLabs Development Environment Setup Script
+# This script sets up a complete development environment
+
+set -e
+
+echo "🚀 Setting up ChaosLabs development environment..."
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_status() {
+ echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+ echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+ echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+ echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check if running in workspace
+if [ ! -f "go.mod" ]; then
+ print_error "Please run this script from the ChaosLabs workspace root"
+ exit 1
+fi
+
+# Setup Git hooks for development
+print_status "Setting up Git hooks..."
+if [ ! -d ".git/hooks" ]; then
+ mkdir -p .git/hooks
+fi
+
+# Pre-commit hook
+cat > .git/hooks/pre-commit << 'EOF'
+#!/bin/bash
+# ChaosLabs pre-commit hook
+
+set -e
+
+echo "Running pre-commit checks..."
+
+# Check Go formatting
+echo "Checking Go formatting..."
+if [ -n "$(gofmt -l .)" ]; then
+ echo "Go code is not formatted. Please run 'gofmt -w .'"
+ exit 1
+fi
+
+# Run Go linting
+echo "Running Go linting..."
+golangci-lint run
+
+# Run Go tests
+echo "Running Go tests..."
+go test ./... -short
+
+# Check frontend formatting (if changed)
+if git diff --cached --name-only | grep -q "dashboard-v2/"; then
+ echo "Checking frontend code..."
+ cd dashboard-v2
+ npm run lint
+ npm run type-check
+ cd ..
+fi
+
+echo "Pre-commit checks passed!"
+EOF
+
+chmod +x .git/hooks/pre-commit
+
+# Setup Go development environment
+print_status "Setting up Go development environment..."
+
+# Download dependencies
+go mod download
+go mod tidy
+
+# Install development tools if not already installed
+tools=(
+ "github.com/golangci/golangci-lint/cmd/golangci-lint@latest"
+ "github.com/go-delve/delve/cmd/dlv@latest"
+ "golang.org/x/tools/cmd/goimports@latest"
+ "github.com/air-verse/air@latest"
+ "golang.org/x/vuln/cmd/govulncheck@latest"
+)
+
+for tool in "${tools[@]}"; do
+ tool_name=$(basename ${tool%@*})
+ if ! command -v $tool_name &> /dev/null; then
+ print_status "Installing $tool_name..."
+ go install $tool
+ else
+ print_success "$tool_name already installed"
+ fi
+done
+
+# Setup frontend development environment
+if [ -d "dashboard-v2" ]; then
+ print_status "Setting up frontend development environment..."
+ cd dashboard-v2
+
+ if [ ! -d "node_modules" ]; then
+ print_status "Installing Node.js dependencies..."
+ npm ci
+ else
+ print_success "Node.js dependencies already installed"
+ fi
+
+ cd ..
+fi
+
+# Create development configuration files
+print_status "Creating development configuration files..."
+
+# Air configuration for Go hot reload
+if [ ! -f ".air.toml" ]; then
+cat > .air.toml << 'EOF'
+root = "."
+testdata_dir = "testdata"
+tmp_dir = "tmp"
+
+[build]
+ args_bin = []
+ bin = "./tmp/main"
+ cmd = "go build -o ./tmp/main ./controller/"
+ delay = 1000
+ exclude_dir = ["assets", "tmp", "vendor", "testdata", "node_modules", "dashboard-v2"]
+ exclude_file = []
+ exclude_regex = ["_test.go"]
+ exclude_unchanged = false
+ follow_symlink = false
+ full_bin = ""
+ include_dir = []
+ include_ext = ["go", "tpl", "tmpl", "html"]
+ kill_delay = "0s"
+ log = "build-errors.log"
+ send_interrupt = false
+ stop_on_root = false
+
+[color]
+ app = ""
+ build = "yellow"
+ main = "magenta"
+ runner = "green"
+ watcher = "cyan"
+
+[log]
+ time = false
+
+[misc]
+ clean_on_exit = false
+
+[screen]
+ clear_on_rebuild = false
+EOF
+fi
+
+# Makefile for common development tasks
+if [ ! -f "Makefile" ]; then
+cat > Makefile << 'EOF'
+.PHONY: help dev build test lint clean docker-dev docker-build
+
+# Default target
+help: ## Show this help message
+ @echo 'Usage: make [target]'
+ @echo ''
+ @echo 'Targets:'
+ @awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf " %-15s %s\n", $$1, $$2}' $(MAKEFILE_LIST)
+
+dev: ## Start development environment
+ docker-compose -f infrastructure/docker-compose.dev.yml up
+
+dev-controller: ## Start controller with hot reload
+ air -c .air.toml
+
+dev-frontend: ## Start frontend development server
+ cd dashboard-v2 && npm run dev
+
+build: ## Build all components
+ go build -o bin/controller ./controller/
+ go build -o bin/agent ./agent/
+ go build -o bin/cli ./cli/
+ cd dashboard-v2 && npm run build
+
+test: ## Run all tests
+ go test ./... -race -coverprofile=coverage.out
+ cd dashboard-v2 && npm test
+
+test-integration: ## Run integration tests
+ go test -tags=integration ./tests/integration/...
+
+lint: ## Run linting
+ golangci-lint run
+ cd dashboard-v2 && npm run lint
+
+format: ## Format code
+ gofmt -w .
+ goimports -w .
+ cd dashboard-v2 && npm run format
+
+clean: ## Clean build artifacts
+ rm -rf bin/
+ rm -rf tmp/
+ rm -rf coverage.out
+ cd dashboard-v2 && rm -rf dist/
+
+docker-dev: ## Build development Docker images
+ docker-compose -f infrastructure/docker-compose.dev.yml build
+
+docker-build: ## Build production Docker images
+ docker build -f infrastructure/Dockerfile.controller.optimized -t chaoslabs/controller:latest .
+ docker build -f infrastructure/Dockerfile.agent.optimized -t chaoslabs/agent:latest .
+
+security-scan: ## Run security scans
+ govulncheck ./...
+ cd dashboard-v2 && npm audit
+
+performance-test: ## Run performance tests
+ k6 run tests/performance/load-test.js
+
+deploy-staging: ## Deploy to staging
+ kubectl apply -f infrastructure/k8s/ --namespace=chaoslabs-staging
+
+logs-controller: ## Show controller logs
+ docker-compose -f infrastructure/docker-compose.dev.yml logs -f controller
+
+logs-agent: ## Show agent logs
+ docker-compose -f infrastructure/docker-compose.dev.yml logs -f agent
+
+db-shell: ## Connect to Redis shell
+ docker-compose -f infrastructure/docker-compose.dev.yml exec redis redis-cli
+
+monitoring: ## Open monitoring dashboards
+ @echo "Opening monitoring dashboards..."
+ @echo "Grafana: http://localhost:3001 (admin/chaoslabs)"
+ @echo "Prometheus: http://localhost:9090"
+ @echo "Jaeger: http://localhost:16686"
+EOF
+fi
+
+# VS Code configuration
+if [ ! -d ".vscode" ]; then
+ mkdir -p .vscode
+
+ # VS Code settings
+ cat > .vscode/settings.json << 'EOF'
+{
+ "go.toolsManagement.checkForUpdates": "local",
+ "go.useLanguageServer": true,
+ "go.gopath": "",
+ "go.goroot": "",
+ "go.lintTool": "golangci-lint",
+ "go.lintFlags": [
+ "--fast"
+ ],
+ "go.formatTool": "goimports",
+ "go.testFlags": ["-v", "-race"],
+ "go.testTimeout": "30s",
+ "go.coverOnSave": true,
+ "go.coverMode": "atomic",
+ "files.exclude": {
+ "**/node_modules": true,
+ "**/tmp": true,
+ "**/bin": true,
+ "**/.git": true
+ },
+ "search.exclude": {
+ "**/node_modules": true,
+ "**/tmp": true,
+ "**/bin": true,
+ "**/vendor": true
+ },
+ "typescript.preferences.quoteStyle": "single",
+ "editor.formatOnSave": true,
+ "editor.codeActionsOnSave": {
+ "source.organizeImports": true
+ }
+}
+EOF
+
+ # VS Code extensions recommendations
+ cat > .vscode/extensions.json << 'EOF'
+{
+ "recommendations": [
+ "golang.go",
+ "ms-vscode.vscode-typescript-next",
+ "bradlc.vscode-tailwindcss",
+ "esbenp.prettier-vscode",
+ "ms-vscode.vscode-eslint",
+ "ms-kubernetes-tools.vscode-kubernetes-tools",
+ "ms-vscode.vscode-docker",
+ "github.vscode-pull-request-github",
+ "streetsidesoftware.code-spell-checker"
+ ]
+}
+EOF
+
+ # VS Code launch configuration
+ cat > .vscode/launch.json << 'EOF'
+{
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "name": "Debug Controller",
+ "type": "go",
+ "request": "launch",
+ "mode": "debug",
+ "program": "${workspaceFolder}/controller",
+ "env": {
+ "LOG_LEVEL": "debug",
+ "REDIS_URL": "redis://localhost:6379",
+ "NATS_URL": "nats://localhost:4222"
+ },
+ "args": []
+ },
+ {
+ "name": "Debug Agent",
+ "type": "go",
+ "request": "launch",
+ "mode": "debug",
+ "program": "${workspaceFolder}/agent",
+ "env": {
+ "LOG_LEVEL": "debug"
+ },
+ "args": []
+ },
+ {
+ "name": "Debug Tests",
+ "type": "go",
+ "request": "launch",
+ "mode": "test",
+ "program": "${workspaceFolder}",
+ "args": [
+ "-test.v"
+ ]
+ }
+ ]
+}
+EOF
+
+fi
+
+# Create environment configuration
+if [ ! -f ".env.development" ]; then
+ cat > .env.development << 'EOF'
+# ChaosLabs Development Environment Configuration
+
+# Logging
+LOG_LEVEL=debug
+LOG_FORMAT=text
+
+# Services
+REDIS_URL=redis://localhost:6379
+NATS_URL=nats://localhost:4222
+JAEGER_ENDPOINT=http://localhost:14268/api/traces
+
+# Controller
+CONTROLLER_PORT=8080
+CONTROLLER_NODE_ID=controller-dev-1
+
+# Agent
+AGENT_PORT=9090
+AGENT_NODE_ID=agent-dev-1
+
+# Dashboard
+DASHBOARD_PORT=3000
+VITE_API_URL=http://localhost:8080
+VITE_WS_URL=ws://localhost:8080/ws
+
+# Database
+MONGO_URI=mongodb://chaoslabs:chaoslabs@localhost:27017/chaoslabs
+
+# Security (development only)
+JWT_SECRET=dev-secret-key-not-for-production
+API_KEY=dev-api-key
+
+# Feature flags
+ENABLE_METRICS=true
+ENABLE_TRACING=true
+ENABLE_PROFILING=true
+EOF
+fi
+
+# Create useful development scripts
+mkdir -p scripts
+
+# Script to reset development environment
+cat > scripts/reset-dev.sh << 'EOF'
+#!/bin/bash
+echo "🔄 Resetting development environment..."
+
+# Stop all containers
+docker-compose -f infrastructure/docker-compose.dev.yml down -v
+
+# Remove build artifacts
+make clean
+
+# Rebuild everything
+docker-compose -f infrastructure/docker-compose.dev.yml build --no-cache
+
+echo "✅ Development environment reset complete!"
+EOF
+
+chmod +x scripts/reset-dev.sh
+
+# Script to run all checks
+cat > scripts/check-all.sh << 'EOF'
+#!/bin/bash
+echo "🔍 Running all quality checks..."
+
+set -e
+
+echo "📝 Running Go linting..."
+golangci-lint run
+
+echo "🧪 Running Go tests..."
+go test ./... -race -coverprofile=coverage.out
+
+echo "🔒 Running security scan..."
+govulncheck ./...
+
+if [ -d "dashboard-v2" ]; then
+ echo "🎨 Running frontend checks..."
+ cd dashboard-v2
+ npm run lint
+ npm run type-check
+ npm test
+ cd ..
+fi
+
+echo "✅ All checks passed!"
+EOF
+
+chmod +x scripts/check-all.sh
+
+# Setup completion
+print_success "Development environment setup complete!"
+print_status "Next steps:"
+echo " 1. Run 'make dev' to start the development environment"
+echo " 2. Run 'make help' to see available commands"
+echo " 3. Open the project in VS Code for the best development experience"
+echo ""
+print_status "Useful commands:"
+echo " • make dev-controller - Start controller with hot reload"
+echo " • make dev-frontend - Start frontend development server"
+echo " • make test - Run all tests"
+echo " • make lint - Run linting"
+echo " • scripts/check-all.sh - Run all quality checks"
+echo ""
+print_status "Monitoring dashboards (after running 'make dev'):"
+echo " • Grafana: http://localhost:3001 (admin/chaoslabs)"
+echo " • Prometheus: http://localhost:9090"
+echo " • Jaeger: http://localhost:16686"
+echo " • Dashboard: http://localhost:3000"
\ No newline at end of file
diff --git a/infrastructure/docker-compose.dev.yml b/infrastructure/docker-compose.dev.yml
new file mode 100644
index 0000000..1db1794
--- /dev/null
+++ b/infrastructure/docker-compose.dev.yml
@@ -0,0 +1,263 @@
+# Development-optimized Docker Compose with hot reload and caching
+version: "3.8"
+
+# Define reusable configurations
+x-logging: &default-logging
+ driver: "json-file"
+ options:
+ max-size: "10m"
+ max-file: "3"
+
+x-common-env: &common-env
+ JAEGER_ENDPOINT: http://jaeger:14268/api/traces
+ REDIS_URL: redis://redis:6379
+ NATS_URL: nats://nats:4222
+ LOG_LEVEL: debug
+ ENVIRONMENT: development
+
+services:
+ # Controller service with hot reload
+ controller:
+ build:
+ context: .
+ dockerfile: infrastructure/Dockerfile.controller.optimized
+ target: development-runtime
+ cache_from:
+ - chaoslabs/controller:build-cache
+ - chaoslabs/controller:development
+ image: chaoslabs/controller:dev
+ ports:
+ - "8080:8080"
+ - "2345:2345" # Delve debugger port
+ environment:
+ <<: *common-env
+ NODE_ID: controller-1
+ AGENT_ENDPOINTS: http://agent:9090/inject
+ volumes:
+ # Hot reload for Go files
+ - ./controller:/app/controller:cached
+ - go-mod-cache:/go/pkg/mod
+ - go-build-cache:/root/.cache/go-build
+ depends_on:
+ - redis
+ - nats
+ - jaeger
+ restart: unless-stopped
+ logging: *default-logging
+ healthcheck:
+ test: ["CMD", "curl", "-f", "http://localhost:8080/healthz"]
+ interval: 15s
+ timeout: 5s
+ retries: 3
+ start_period: 10s
+
+ # Agent service with hot reload
+ agent:
+ build:
+ context: .
+ dockerfile: infrastructure/Dockerfile.agent.optimized
+ target: development-runtime
+ image: chaoslabs/agent:dev
+ ports:
+ - "9090:9090"
+ - "2346:2345" # Delve debugger port
+ environment:
+ <<: *common-env
+ NODE_ID: agent-1
+ volumes:
+ - ./agent:/app/agent:cached
+ - go-mod-cache:/go/pkg/mod
+ - go-build-cache:/root/.cache/go-build
+ privileged: true # Required for network chaos experiments
+ cap_add:
+ - NET_ADMIN
+ - SYS_ADMIN
+ depends_on:
+ - jaeger
+ restart: unless-stopped
+ logging: *default-logging
+
+ # Enhanced dashboard with Node.js caching
+ dashboard:
+ build:
+ context: ./dashboard-v2
+ dockerfile: Dockerfile.dev
+ image: chaoslabs/dashboard:dev
+ ports:
+ - "3000:3000"
+ - "3001:3001" # WebSocket dev server
+ environment:
+ - NODE_ENV=development
+ - VITE_API_URL=http://localhost:8080
+ - VITE_WS_URL=ws://localhost:8080/ws
+ - CHOKIDAR_USEPOLLING=true
+ volumes:
+ - ./dashboard-v2:/app:cached
+ - node-modules-cache:/app/node_modules
+ - vite-cache:/app/.vite
+ restart: unless-stopped
+ logging: *default-logging
+
+ # Redis with persistence and optimized config
+ redis:
+ image: redis:7-alpine
+ ports:
+ - "6379:6379"
+ volumes:
+ - redis-data:/data
+ - ./infrastructure/redis/redis-dev.conf:/usr/local/etc/redis/redis.conf:ro
+ command: redis-server /usr/local/etc/redis/redis.conf
+ restart: unless-stopped
+ logging: *default-logging
+ healthcheck:
+ test: ["CMD", "redis-cli", "ping"]
+ interval: 10s
+ timeout: 3s
+ retries: 3
+
+ # NATS for event streaming
+ nats:
+ image: nats:2.10-alpine
+ ports:
+ - "4222:4222"
+ - "8222:8222" # HTTP monitoring
+ command:
+ - "--jetstream"
+ - "--store_dir=/data"
+ - "--http_port=8222"
+ - "--max_payload=1MB"
+ - "--max_pending=10MB"
+ volumes:
+ - nats-data:/data
+ restart: unless-stopped
+ logging: *default-logging
+
+ # Jaeger for distributed tracing
+ jaeger:
+ image: jaegertracing/all-in-one:1.50
+ ports:
+ - "16686:16686" # Jaeger UI
+ - "14268:14268" # Jaeger collector
+ environment:
+ - COLLECTOR_OTLP_ENABLED=true
+ - MEMORY_MAX_TRACES=10000
+ volumes:
+ - jaeger-data:/tmp
+ restart: unless-stopped
+ logging: *default-logging
+
+ # Prometheus for metrics collection
+ prometheus:
+ image: prom/prometheus:v2.47.0
+ ports:
+ - "9090:9090"
+ volumes:
+ - ./infrastructure/prometheus/prometheus-dev.yml:/etc/prometheus/prometheus.yml:ro
+ - prometheus-data:/prometheus
+ command:
+ - '--config.file=/etc/prometheus/prometheus.yml'
+ - '--storage.tsdb.path=/prometheus'
+ - '--web.console.libraries=/etc/prometheus/console_libraries'
+ - '--web.console.templates=/etc/prometheus/consoles'
+ - '--storage.tsdb.retention.time=7d'
+ - '--web.enable-lifecycle'
+ - '--web.enable-admin-api'
+ restart: unless-stopped
+ logging: *default-logging
+
+ # Grafana for metrics visualization
+ grafana:
+ image: grafana/grafana:10.1.0
+ ports:
+ - "3001:3000"
+ environment:
+ - GF_SECURITY_ADMIN_PASSWORD=chaoslabs
+ - GF_INSTALL_PLUGINS=grafana-clock-panel,grafana-simple-json-datasource
+ volumes:
+ - grafana-data:/var/lib/grafana
+ - ./infrastructure/grafana/provisioning:/etc/grafana/provisioning:ro
+ - ./infrastructure/grafana/dashboards:/var/lib/grafana/dashboards:ro
+ depends_on:
+ - prometheus
+ restart: unless-stopped
+ logging: *default-logging
+
+ # MongoDB for time-series data (optional)
+ mongodb:
+ image: mongo:7.0
+ ports:
+ - "27017:27017"
+ environment:
+ - MONGO_INITDB_ROOT_USERNAME=chaoslabs
+ - MONGO_INITDB_ROOT_PASSWORD=chaoslabs
+ - MONGO_INITDB_DATABASE=chaoslabs
+ volumes:
+ - mongodb-data:/data/db
+ - ./infrastructure/mongodb/init-mongo.js:/docker-entrypoint-initdb.d/init-mongo.js:ro
+ restart: unless-stopped
+ logging: *default-logging
+
+ # Development tools container
+ devtools:
+ build:
+ context: ./infrastructure/devtools
+ dockerfile: Dockerfile
+ image: chaoslabs/devtools:latest
+ volumes:
+ - .:/workspace:cached
+ - go-mod-cache:/go/pkg/mod
+ - go-build-cache:/root/.cache/go-build
+ - node-modules-cache:/workspace/dashboard-v2/node_modules
+ working_dir: /workspace
+ tty: true
+ stdin_open: true
+ profiles:
+ - tools
+
+ # Load testing with k6
+ k6:
+ image: grafana/k6:0.46.0
+ volumes:
+ - ./tests/load:/scripts:ro
+ - k6-data:/app
+ profiles:
+ - testing
+ logging: *default-logging
+
+volumes:
+ # Go caching for faster builds
+ go-mod-cache:
+ driver: local
+ go-build-cache:
+ driver: local
+
+ # Node.js caching
+ node-modules-cache:
+ driver: local
+ vite-cache:
+ driver: local
+
+ # Application data
+ redis-data:
+ driver: local
+ nats-data:
+ driver: local
+ prometheus-data:
+ driver: local
+ grafana-data:
+ driver: local
+ mongodb-data:
+ driver: local
+ jaeger-data:
+ driver: local
+ k6-data:
+ driver: local
+
+networks:
+ default:
+ name: chaoslabs-dev
+ driver: bridge
+ ipam:
+ driver: default
+ config:
+ - subnet: 172.20.0.0/16
\ No newline at end of file
diff --git a/infrastructure/performance-report.sh b/infrastructure/performance-report.sh
new file mode 100644
index 0000000..4bc9888
--- /dev/null
+++ b/infrastructure/performance-report.sh
@@ -0,0 +1,883 @@
+#!/bin/bash
+
+# CI/CD Performance Analysis and Reporting Script
+# Analyzes build times, cache effectiveness, and generates optimization recommendations
+
+set -e
+
+# Configuration
+REPORT_DIR="reports/performance"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+REPORT_FILE="$REPORT_DIR/ci_performance_$TIMESTAMP.json"
+HTML_REPORT="$REPORT_DIR/ci_performance_$TIMESTAMP.html"
+
+# Colors
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+print_status() { echo -e "${BLUE}[PERF]${NC} $1"; }
+print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
+print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
+print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
+
+# Initialize report structure
+init_report() {
+ mkdir -p "$REPORT_DIR"
+
+ cat > "$REPORT_FILE" << EOF
+{
+ "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+ "version": "2.0",
+ "metadata": {
+ "git_commit": "$(git rev-parse HEAD 2>/dev/null || echo 'unknown')",
+ "git_branch": "$(git branch --show-current 2>/dev/null || echo 'unknown')",
+ "ci_system": "${CI:-local}",
+ "runner_os": "$(uname -s)",
+ "runner_arch": "$(uname -m)"
+ },
+ "build_performance": {},
+ "cache_analysis": {},
+ "test_performance": {},
+ "docker_performance": {},
+ "recommendations": []
+}
+EOF
+}
+
+# Analyze Go build performance
+analyze_go_performance() {
+ print_status "Analyzing Go build performance..."
+
+ local go_data="{}"
+
+ if command -v go &> /dev/null; then
+ # Measure build times for each component
+ for component in controller agent cli; do
+ if [ -d "$component" ]; then
+ print_status "Measuring $component build time..."
+
+ # Clean build
+ (cd "$component" && go clean -cache)
+ local start_time=$(date +%s.%N)
+ (cd "$component" && go build -o /tmp/test_build . 2>/dev/null) || true
+ local end_time=$(date +%s.%N)
+ local cold_build_time=$(echo "$end_time - $start_time" | bc)
+
+ # Warm build
+ local start_time=$(date +%s.%N)
+ (cd "$component" && go build -o /tmp/test_build . 2>/dev/null) || true
+ local end_time=$(date +%s.%N)
+ local warm_build_time=$(echo "$end_time - $start_time" | bc)
+
+ # Test compilation time
+ local start_time=$(date +%s.%N)
+ (cd "$component" && go test -c ./... 2>/dev/null) || true
+ local end_time=$(date +%s.%N)
+ local test_build_time=$(echo "$end_time - $start_time" | bc)
+
+ # Cache statistics
+ local cache_size=$(go env GOCACHE | xargs du -sb 2>/dev/null | cut -f1 || echo "0")
+ local mod_cache_size=$(go env GOMODCACHE | xargs du -sb 2>/dev/null | cut -f1 || echo "0")
+
+ go_data=$(echo "$go_data" | jq --arg component "$component" \
+ --arg cold_build "$cold_build_time" \
+ --arg warm_build "$warm_build_time" \
+ --arg test_build "$test_build_time" \
+ --arg cache_size "$cache_size" \
+ --arg mod_cache_size "$mod_cache_size" \
+ '. + {($component): {
+ "cold_build_seconds": ($cold_build | tonumber),
+ "warm_build_seconds": ($warm_build | tonumber),
+ "test_build_seconds": ($test_build | tonumber),
+ "cache_size_bytes": ($cache_size | tonumber),
+ "mod_cache_size_bytes": ($mod_cache_size | tonumber),
+ "cache_effectiveness": (($cold_build | tonumber) / ($warm_build | tonumber))
+ }}')
+
+ rm -f /tmp/test_build
+ fi
+ done
+
+ # Overall Go statistics
+ local total_deps=$(find . -name go.mod -exec grep -c "require" {} \; | awk '{sum+=$1} END {print sum}' || echo "0")
+ local go_version=$(go version | grep -o 'go[0-9.]*' || echo "unknown")
+
+ go_data=$(echo "$go_data" | jq --arg total_deps "$total_deps" \
+ --arg go_version "$go_version" \
+ '. + {
+ "summary": {
+ "go_version": $go_version,
+ "total_dependencies": ($total_deps | tonumber),
+ "modules_count": '"$(find . -name go.mod | wc -l)"'
+ }
+ }')
+ fi
+
+ # Update main report
+ jq --argjson go_data "$go_data" '.build_performance.go = $go_data' "$REPORT_FILE" > /tmp/report.json && mv /tmp/report.json "$REPORT_FILE"
+}
+
+# Analyze Node.js build performance
+analyze_node_performance() {
+ print_status "Analyzing Node.js build performance..."
+
+ local node_data="{}"
+
+ if command -v npm &> /dev/null && [ -d "dashboard-v2" ]; then
+ cd dashboard-v2
+
+ # Measure install time
+ rm -rf node_modules package-lock.json 2>/dev/null || true
+ local start_time=$(date +%s.%N)
+ npm install --silent 2>/dev/null || true
+ local end_time=$(date +%s.%N)
+ local install_time=$(echo "$end_time - $start_time" | bc)
+
+ # Measure build time
+ local start_time=$(date +%s.%N)
+ npm run build --silent 2>/dev/null || true
+ local end_time=$(date +%s.%N)
+ local build_time=$(echo "$end_time - $start_time" | bc)
+
+ # Cache statistics
+ local npm_cache_size=$(npm config get cache | xargs du -sb 2>/dev/null | cut -f1 || echo "0")
+ local node_modules_size=$(du -sb node_modules 2>/dev/null | cut -f1 || echo "0")
+
+ # Bundle analysis
+ local bundle_size=0
+ if [ -d "dist" ]; then
+ bundle_size=$(du -sb dist 2>/dev/null | cut -f1 || echo "0")
+ fi
+
+ # Dependencies count
+ local deps_count=$(jq '.dependencies | length' package.json 2>/dev/null || echo "0")
+ local dev_deps_count=$(jq '.devDependencies | length' package.json 2>/dev/null || echo "0")
+
+ node_data=$(jq -n \
+ --arg install_time "$install_time" \
+ --arg build_time "$build_time" \
+ --arg npm_cache_size "$npm_cache_size" \
+ --arg node_modules_size "$node_modules_size" \
+ --arg bundle_size "$bundle_size" \
+ --arg deps_count "$deps_count" \
+ --arg dev_deps_count "$dev_deps_count" \
+ '{
+ "install_seconds": ($install_time | tonumber),
+ "build_seconds": ($build_time | tonumber),
+ "npm_cache_size_bytes": ($npm_cache_size | tonumber),
+ "node_modules_size_bytes": ($node_modules_size | tonumber),
+ "bundle_size_bytes": ($bundle_size | tonumber),
+ "dependencies_count": ($deps_count | tonumber),
+ "dev_dependencies_count": ($dev_deps_count | tonumber),
+ "node_version": "'"$(node --version 2>/dev/null || echo 'unknown')"'",
+ "npm_version": "'"$(npm --version 2>/dev/null || echo 'unknown')"'"
+ }')
+
+ cd ..
+ fi
+
+ # Update main report
+ jq --argjson node_data "$node_data" '.build_performance.node = $node_data' "$REPORT_FILE" > /tmp/report.json && mv /tmp/report.json "$REPORT_FILE"
+}
+
+# Analyze Docker build performance
+analyze_docker_performance() {
+ print_status "Analyzing Docker build performance..."
+
+ local docker_data="{}"
+
+ if command -v docker &> /dev/null; then
+ # Measure Docker build times
+ for component in controller agent dashboard; do
+ if [ -f "infrastructure/Dockerfile.$component.optimized" ]; then
+ print_status "Measuring Docker build time for $component..."
+
+ # Cold build (no cache)
+ docker builder prune -f > /dev/null 2>&1 || true
+ local start_time=$(date +%s.%N)
+ docker build \
+ -f "infrastructure/Dockerfile.$component.optimized" \
+ --target production \
+ -t "test-$component:latest" \
+ . > /dev/null 2>&1 || true
+ local end_time=$(date +%s.%N)
+ local cold_build_time=$(echo "$end_time - $start_time" | bc)
+
+ # Warm build (with cache)
+ local start_time=$(date +%s.%N)
+ docker build \
+ -f "infrastructure/Dockerfile.$component.optimized" \
+ --target production \
+ -t "test-$component:cached" \
+ . > /dev/null 2>&1 || true
+ local end_time=$(date +%s.%N)
+ local warm_build_time=$(echo "$end_time - $start_time" | bc)
+
+ # Image size
+ local image_size=$(docker images --format "table {{.Size}}" "test-$component:latest" | tail -n 1 | numfmt --from=iec --to-unit=1 || echo "0")
+
+ docker_data=$(echo "$docker_data" | jq --arg component "$component" \
+ --arg cold_build "$cold_build_time" \
+ --arg warm_build "$warm_build_time" \
+ --arg image_size "$image_size" \
+ '. + {($component): {
+ "cold_build_seconds": ($cold_build | tonumber),
+ "warm_build_seconds": ($warm_build | tonumber),
+ "image_size_bytes": ($image_size | tonumber),
+ "cache_effectiveness": (($cold_build | tonumber) / (($warm_build | tonumber) + 0.1))
+ }}')
+
+ # Clean up test images
+ docker rmi "test-$component:latest" "test-$component:cached" > /dev/null 2>&1 || true
+ fi
+ done
+
+ # Docker system information
+ local docker_version=$(docker version --format '{{.Server.Version}}' 2>/dev/null || echo "unknown")
+ local buildkit_enabled=$(docker version --format '{{.Server.BuildkitVersion}}' 2>/dev/null | grep -q . && echo "true" || echo "false")
+ local total_images=$(docker images -q | wc -l)
+ local cache_usage=$(docker system df --format "table {{.Type}}\t{{.Size}}" | grep "Build Cache" | awk '{print $3}' | numfmt --from=iec --to-unit=1 2>/dev/null || echo "0")
+
+ docker_data=$(echo "$docker_data" | jq --arg docker_version "$docker_version" \
+ --arg buildkit_enabled "$buildkit_enabled" \
+ --arg total_images "$total_images" \
+ --arg cache_usage "$cache_usage" \
+ '. + {
+ "summary": {
+ "docker_version": $docker_version,
+ "buildkit_enabled": ($buildkit_enabled | test("true")),
+ "total_images": ($total_images | tonumber),
+ "cache_usage_bytes": ($cache_usage | tonumber)
+ }
+ }')
+ fi
+
+ # Update main report
+ jq --argjson docker_data "$docker_data" '.docker_performance = $docker_data' "$REPORT_FILE" > /tmp/report.json && mv /tmp/report.json "$REPORT_FILE"
+}
+
+# Analyze test performance
+analyze_test_performance() {
+ print_status "Analyzing test performance..."
+
+ local test_data="{}"
+
+ if command -v go &> /dev/null; then
+ for component in controller agent cli; do
+ if [ -d "$component" ]; then
+ print_status "Measuring test performance for $component..."
+
+ cd "$component"
+
+ # Run tests with timing
+ local start_time=$(date +%s.%N)
+ local test_output=$(go test -v ./... 2>&1 || true)
+ local end_time=$(date +%s.%N)
+ local test_duration=$(echo "$end_time - $start_time" | bc)
+
+ # Parse test results
+ local total_tests=$(echo "$test_output" | grep -c "=== RUN" || echo "0")
+ local passed_tests=$(echo "$test_output" | grep -c "--- PASS:" || echo "0")
+ local failed_tests=$(echo "$test_output" | grep -c "--- FAIL:" || echo "0")
+ local skipped_tests=$(echo "$test_output" | grep -c "--- SKIP:" || echo "0")
+
+ # Coverage analysis
+ go test -coverprofile=coverage.out ./... > /dev/null 2>&1 || true
+ local coverage_percent="0"
+ if [ -f "coverage.out" ]; then
+ coverage_percent=$(go tool cover -func=coverage.out | tail -n 1 | awk '{print $3}' | sed 's/%//' || echo "0")
+ rm coverage.out
+ fi
+
+ test_data=$(echo "$test_data" | jq --arg component "$component" \
+ --arg duration "$test_duration" \
+ --arg total "$total_tests" \
+ --arg passed "$passed_tests" \
+ --arg failed "$failed_tests" \
+ --arg skipped "$skipped_tests" \
+ --arg coverage "$coverage_percent" \
+ '. + {($component): {
+ "duration_seconds": ($duration | tonumber),
+ "total_tests": ($total | tonumber),
+ "passed_tests": ($passed | tonumber),
+ "failed_tests": ($failed | tonumber),
+ "skipped_tests": ($skipped | tonumber),
+ "coverage_percent": ($coverage | tonumber),
+ "success_rate": (($passed | tonumber) / (($total | tonumber) + 0.1))
+ }}')
+
+ cd ..
+ fi
+ done
+ fi
+
+ # Frontend tests
+ if command -v npm &> /dev/null && [ -d "dashboard-v2" ]; then
+ cd dashboard-v2
+
+ local start_time=$(date +%s.%N)
+ npm test -- --watchAll=false --coverage --silent > /dev/null 2>&1 || true
+ local end_time=$(date +%s.%N)
+ local frontend_test_duration=$(echo "$end_time - $start_time" | bc)
+
+ # Extract coverage if available
+ local frontend_coverage="0"
+ if [ -f "coverage/lcov-report/index.html" ]; then
+ frontend_coverage=$(grep -o '[0-9.]*%' coverage/lcov-report/index.html | head -n 1 | sed 's/%//' || echo "0")
+ fi
+
+ test_data=$(echo "$test_data" | jq --arg duration "$frontend_test_duration" \
+ --arg coverage "$frontend_coverage" \
+ '. + {
+ "frontend": {
+ "duration_seconds": ($duration | tonumber),
+ "coverage_percent": ($coverage | tonumber)
+ }
+ }')
+
+ cd ..
+ fi
+
+ # Update main report
+ jq --argjson test_data "$test_data" '.test_performance = $test_data' "$REPORT_FILE" > /tmp/report.json && mv /tmp/report.json "$REPORT_FILE"
+}
+
+# Analyze cache effectiveness
+analyze_cache_effectiveness() {
+ print_status "Analyzing cache effectiveness..."
+
+ local cache_data="{}"
+
+ # Go cache analysis
+ if command -v go &> /dev/null; then
+ local go_cache_dir=$(go env GOCACHE)
+ local go_cache_size=0
+ local go_cache_files=0
+
+ if [ -d "$go_cache_dir" ]; then
+ go_cache_size=$(du -sb "$go_cache_dir" 2>/dev/null | cut -f1 || echo "0")
+ go_cache_files=$(find "$go_cache_dir" -type f | wc -l || echo "0")
+ fi
+
+ local mod_cache_dir=$(go env GOMODCACHE)
+ local mod_cache_size=0
+ local mod_cache_modules=0
+
+ if [ -d "$mod_cache_dir" ]; then
+ mod_cache_size=$(du -sb "$mod_cache_dir" 2>/dev/null | cut -f1 || echo "0")
+ mod_cache_modules=$(find "$mod_cache_dir" -maxdepth 2 -type d | wc -l || echo "0")
+ fi
+
+ cache_data=$(echo "$cache_data" | jq --arg go_cache_size "$go_cache_size" \
+ --arg go_cache_files "$go_cache_files" \
+ --arg mod_cache_size "$mod_cache_size" \
+ --arg mod_cache_modules "$mod_cache_modules" \
+ '. + {
+ "go": {
+ "build_cache_size_bytes": ($go_cache_size | tonumber),
+ "build_cache_files": ($go_cache_files | tonumber),
+ "module_cache_size_bytes": ($mod_cache_size | tonumber),
+ "cached_modules": ($mod_cache_modules | tonumber)
+ }
+ }')
+ fi
+
+ # Node cache analysis
+ if command -v npm &> /dev/null; then
+ local npm_cache_dir=$(npm config get cache)
+ local npm_cache_size=0
+ local npm_cache_packages=0
+
+ if [ -d "$npm_cache_dir" ]; then
+ npm_cache_size=$(du -sb "$npm_cache_dir" 2>/dev/null | cut -f1 || echo "0")
+ npm_cache_packages=$(find "$npm_cache_dir" -name "package.json" | wc -l || echo "0")
+ fi
+
+ cache_data=$(echo "$cache_data" | jq --arg npm_cache_size "$npm_cache_size" \
+ --arg npm_cache_packages "$npm_cache_packages" \
+ '. + {
+ "npm": {
+ "cache_size_bytes": ($npm_cache_size | tonumber),
+ "cached_packages": ($npm_cache_packages | tonumber)
+ }
+ }')
+ fi
+
+ # Docker cache analysis
+ if command -v docker &> /dev/null; then
+ local docker_cache_info=$(docker system df --format "json" 2>/dev/null || echo '{}')
+
+ cache_data=$(echo "$cache_data" | jq --argjson docker_info "$docker_cache_info" \
+ '. + {"docker": $docker_info}')
+ fi
+
+ # Update main report
+ jq --argjson cache_data "$cache_data" '.cache_analysis = $cache_data' "$REPORT_FILE" > /tmp/report.json && mv /tmp/report.json "$REPORT_FILE"
+}
+
+# Generate recommendations
+generate_recommendations() {
+ print_status "Generating optimization recommendations..."
+
+ local recommendations='[]'
+
+ # Analyze the report data and generate recommendations
+ local go_build_data=$(jq '.build_performance.go' "$REPORT_FILE")
+ local node_build_data=$(jq '.build_performance.node' "$REPORT_FILE")
+ local docker_data=$(jq '.docker_performance' "$REPORT_FILE")
+ local test_data=$(jq '.test_performance' "$REPORT_FILE")
+
+ # Go-specific recommendations
+ if [ "$go_build_data" != "null" ]; then
+ # Check for slow builds
+ local max_build_time=$(echo "$go_build_data" | jq '[.[].cold_build_seconds] | max // 0')
+ if (( $(echo "$max_build_time > 30" | bc -l) )); then
+ recommendations=$(echo "$recommendations" | jq '. + [{
+ "category": "go_build",
+ "priority": "high",
+ "title": "Slow Go Build Detected",
+ "description": "Go build times exceed 30 seconds. Consider using build caching and parallel compilation.",
+ "actions": [
+ "Enable Go module proxy (GOPROXY=https://proxy.golang.org,direct)",
+ "Use go build -a flag for cleaner builds",
+ "Consider using go:embed for static assets",
+ "Profile build with go build -x for bottleneck analysis"
+ ]
+ }]')
+ fi
+
+ # Check cache effectiveness
+ local min_cache_effectiveness=$(echo "$go_build_data" | jq '[.[].cache_effectiveness] | min // 0')
+ if (( $(echo "$min_cache_effectiveness < 3" | bc -l) )); then
+ recommendations=$(echo "$recommendations" | jq '. + [{
+ "category": "go_cache",
+ "priority": "medium",
+ "title": "Go Cache Not Effective",
+ "description": "Go build cache is not providing significant speedup. Cache may be corrupted or not properly utilized.",
+ "actions": [
+ "Clean and rebuild cache with go clean -cache",
+ "Ensure GOCACHE is on fast storage (SSD)",
+ "Consider using shared cache in CI/CD",
+ "Verify cache directory permissions"
+ ]
+ }]')
+ fi
+ fi
+
+ # Node.js-specific recommendations
+ if [ "$node_build_data" != "null" ]; then
+ local node_install_time=$(echo "$node_build_data" | jq '.install_seconds // 0')
+ if (( $(echo "$node_install_time > 60" | bc -l) )); then
+ recommendations=$(echo "$recommendations" | jq '. + [{
+ "category": "node_build",
+ "priority": "high",
+ "title": "Slow npm install Detected",
+ "description": "npm install takes more than 60 seconds. Consider optimization strategies.",
+ "actions": [
+ "Use npm ci instead of npm install in CI/CD",
+ "Enable npm cache and ensure it is on fast storage",
+ "Consider using pnpm for faster installs",
+ "Audit and remove unused dependencies",
+ "Use .npmrc for registry optimization"
+ ]
+ }]')
+ fi
+
+ local bundle_size=$(echo "$node_build_data" | jq '.bundle_size_bytes // 0')
+ if (( $(echo "$bundle_size > 5000000" | bc -l) )); then # > 5MB
+ recommendations=$(echo "$recommendations" | jq '. + [{
+ "category": "bundle_size",
+ "priority": "medium",
+ "title": "Large Bundle Size Detected",
+ "description": "Frontend bundle exceeds 5MB. Consider code splitting and optimization.",
+ "actions": [
+ "Implement code splitting with dynamic imports",
+ "Enable tree shaking in build configuration",
+ "Optimize images and use modern formats (WebP, AVIF)",
+ "Use bundle analyzer to identify large dependencies",
+ "Consider lazy loading for non-critical components"
+ ]
+ }]')
+ fi
+ fi
+
+ # Docker-specific recommendations
+ if [ "$docker_data" != "null" ]; then
+ local docker_summary=$(echo "$docker_data" | jq '.summary // {}')
+ local buildkit_enabled=$(echo "$docker_summary" | jq '.buildkit_enabled // false')
+
+ if [ "$buildkit_enabled" != "true" ]; then
+ recommendations=$(echo "$recommendations" | jq '. + [{
+ "category": "docker_optimization",
+ "priority": "high",
+ "title": "Docker BuildKit Not Enabled",
+ "description": "Docker BuildKit provides significant build performance improvements.",
+ "actions": [
+ "Enable BuildKit with DOCKER_BUILDKIT=1",
+ "Use multi-stage builds with cache mounts",
+ "Implement cache mount syntax for package managers",
+ "Consider using Docker Compose build contexts"
+ ]
+ }]')
+ fi
+
+ # Check for slow Docker builds
+ for component in controller agent dashboard; do
+ local cold_build=$(echo "$docker_data" | jq --arg comp "$component" '.[$comp].cold_build_seconds // 0')
+ if (( $(echo "$cold_build > 120" | bc -l) )); then # > 2 minutes
+ recommendations=$(echo "$recommendations" | jq --arg comp "$component" '. + [{
+ "category": "docker_build",
+ "priority": "medium",
+ "title": ("Slow Docker Build for " + $comp),
+ "description": ("Docker build for " + $comp + " takes more than 2 minutes."),
+ "actions": [
+ "Optimize Dockerfile layer caching",
+ "Use smaller base images (alpine variants)",
+ "Minimize context size with .dockerignore",
+ "Use cache-from and cache-to build arguments"
+ ]
+ }]')
+ fi
+ done
+ fi
+
+ # Test performance recommendations
+ if [ "$test_data" != "null" ]; then
+ for component in controller agent cli; do
+ local test_duration=$(echo "$test_data" | jq --arg comp "$component" '.[$comp].duration_seconds // 0')
+ if (( $(echo "$test_duration > 30" | bc -l) )); then
+ recommendations=$(echo "$recommendations" | jq --arg comp "$component" '. + [{
+ "category": "test_performance",
+ "priority": "medium",
+ "title": ("Slow Tests in " + $comp),
+ "description": ("Test suite for " + $comp + " takes more than 30 seconds."),
+ "actions": [
+ "Use t.Parallel() for independent tests",
+ "Implement test caching with testify",
+ "Mock external dependencies",
+ "Use build tags to separate unit/integration tests",
+ "Consider running tests in parallel with -p flag"
+ ]
+ }]')
+ fi
+
+ local coverage=$(echo "$test_data" | jq --arg comp "$component" '.[$comp].coverage_percent // 0')
+ if (( $(echo "$coverage < 80" | bc -l) )); then
+ recommendations=$(echo "$recommendations" | jq --arg comp "$component" '. + [{
+ "category": "test_coverage",
+ "priority": "low",
+ "title": ("Low Test Coverage in " + $comp),
+ "description": ("Test coverage for " + $comp + " is below 80%."),
+ "actions": [
+ "Add unit tests for uncovered functions",
+ "Implement table-driven tests for edge cases",
+ "Add integration tests for critical paths",
+ "Use coverage tools to identify gaps"
+ ]
+ }]')
+ fi
+ done
+ fi
+
+ # General CI/CD recommendations
+ recommendations=$(echo "$recommendations" | jq '. + [{
+ "category": "ci_optimization",
+ "priority": "medium",
+ "title": "CI/CD Pipeline Optimization",
+ "description": "General recommendations for improving CI/CD performance.",
+ "actions": [
+ "Use matrix builds for parallel execution",
+ "Implement smart change detection to skip unnecessary jobs",
+ "Use self-hosted runners for consistent performance",
+ "Cache dependencies between builds",
+ "Use fail-fast strategy for quick feedback"
+ ]
+ }]')
+
+ # Update main report
+ jq --argjson recommendations "$recommendations" '.recommendations = $recommendations' "$REPORT_FILE" > /tmp/report.json && mv /tmp/report.json "$REPORT_FILE"
+}
+
+# Generate HTML report
+generate_html_report() {
+ print_status "Generating HTML report..."
+
+ cat > "$HTML_REPORT" << 'EOF'
+
+
+
+
+
+ ChaosLabs CI/CD Performance Report
+
+
+
+
+
+
🚀 ChaosLabs CI/CD Performance Report
+
Generated:
+
+
+
📊 Performance Summary
+
+
+
+
+
📈 Performance Charts
+
+
+
+
+
+
+
+
+
+
🔍 Detailed Analysis
+
+
+
+
+
💡 Optimization Recommendations
+
+
+
+
+
+
+
+EOF
+
+ # Replace placeholder with actual data
+ local json_data=$(cat "$REPORT_FILE" | jq -c .)
+ sed -i "s/REPORT_DATA_PLACEHOLDER/$json_data/g" "$HTML_REPORT" 2>/dev/null || \
+ sed -i '' "s/REPORT_DATA_PLACEHOLDER/$json_data/g" "$HTML_REPORT"
+}
+
+# Main execution
+main() {
+ print_status "Starting CI/CD performance analysis..."
+
+ # Check dependencies
+ if ! command -v jq &> /dev/null; then
+ print_error "jq is required but not installed. Please install jq first."
+ exit 1
+ fi
+
+ if ! command -v bc &> /dev/null; then
+ print_error "bc is required but not installed. Please install bc first."
+ exit 1
+ fi
+
+ # Initialize report
+ init_report
+
+ # Run analyses
+ analyze_go_performance
+ analyze_node_performance
+ analyze_docker_performance
+ analyze_test_performance
+ analyze_cache_effectiveness
+ generate_recommendations
+ generate_html_report
+
+ # Summary
+ print_success "Performance analysis complete!"
+ echo ""
+ echo "📄 Reports generated:"
+ echo " JSON: $REPORT_FILE"
+ echo " HTML: $HTML_REPORT"
+ echo ""
+
+ # Quick summary
+ if command -v jq &> /dev/null; then
+ local total_recommendations=$(jq '.recommendations | length' "$REPORT_FILE")
+ local high_priority=$(jq '[.recommendations[] | select(.priority == "high")] | length' "$REPORT_FILE")
+
+ echo "📊 Quick Summary:"
+ echo " Total recommendations: $total_recommendations"
+ echo " High priority items: $high_priority"
+ echo ""
+
+ if [ "$high_priority" -gt 0 ]; then
+ print_warning "⚠️ High priority optimizations available!"
+ echo "Review the HTML report for detailed recommendations."
+ else
+ print_success "✅ No critical performance issues detected."
+ fi
+ fi
+
+ echo ""
+ echo "🔧 To apply optimizations, review the recommendations in the HTML report:"
+ echo " open $HTML_REPORT"
+}
+
+# Run main function
+main "$@"
\ No newline at end of file