# observability/otel-collector-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-collector-conf
  namespace: observability
data:
  otel-collector-config: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: 0.0.0.0:4317
          http:
            endpoint: 0.0.0.0:4318
      
      prometheus:
        config:
          global:
            scrape_interval: 30s
          scrape_configs:
            - job_name: 'kubernetes-pods'
              kubernetes_sd_configs:
                - role: pod
              relabel_configs:
                - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
                  action: keep
                  regex: true
                - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
                  action: replace
                  target_label: __metrics_path__
                  regex: (.+)
                - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
                  action: replace
                  regex: ([^:]+)(?::\d+)?;(\d+)
                  replacement: $1:$2
                  target_label: __address__
    
    processors:
      batch:
        timeout: 10s
        send_batch_size: 1000
      resource:
        attributes:
          - key: k8s.cluster.name
            value: "production-cluster"
            action: upsert
      memory_limiter:
        check_interval: 1s
        limit_mib: 2000
        spike_limit_mib: 500
    
    exporters:
      logging:
        loglevel: debug
      prometheus:
        endpoint: "0.0.0.0:9090"
        namespace: app_metrics
        const_labels:
          cluster: "production"
      jaeger:
        endpoint: jaeger-collector.observability:14250
        tls:
          insecure: true
    
    service:
      pipelines:
        metrics:
          receivers: [otlp, prometheus]
          processors: [batch, memory_limiter, resource]
          exporters: [logging, prometheus]
        traces:
          receivers: [otlp]
          processors: [batch, memory_limiter, resource]
          exporters: [logging, jaeger]

  

# app/observability/instrumentation.py
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.resources import Resource
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.instrumentation.redis import RedisInstrumentor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor

def setup_tracing(service_name: str, endpoint: str = None):
    """
    Initialize distributed tracing for the application
    """
    # Create tracer provider with resource attributes
    resource = Resource.create({
        "service.name": service_name,
        "service.version": os.getenv("APP_VERSION", "1.0.0"),
        "deployment.environment": os.getenv("ENVIRONMENT", "development")
    })
    
    tracer_provider = TracerProvider(resource=resource)
    
    # Configure OTLP exporter
    otlp_exporter = OTLPSpanExporter(
        endpoint=endpoint or os.getenv("OTLP_ENDPOINT", "otel-collector:4317"),
        insecure=True
    )
    
    # Add batch processor
    span_processor = BatchSpanProcessor(otlp_exporter)
    tracer_provider.add_span_processor(span_processor)
    
    # Set the global tracer provider
    trace.set_tracer_provider(tracer_provider)
    
    # Auto-instrument common libraries
    FastAPIInstrumentor().instrument()
    RequestsInstrumentor().instrument()
    RedisInstrumentor().instrument()
    SQLAlchemyInstrumentor().instrument()
    
    return trace.get_tracer(__name__)

# Example usage in FastAPI application
from fastapi import FastAPI
import requests

app = FastAPI(title="User Service")

# Initialize tracing
tracer = setup_tracing("user-service")

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    with tracer.start_as_current_span("get_user_request") as span:
        span.set_attribute("user.id", user_id)
        
        # This call will be automatically traced
        response = requests.get(f"http://profile-service/profiles/{user_id}")
        
        span.set_attribute("http.status_code", response.status_code)
        return response.json()

# Custom tracing for business logic
def process_user_order(user_id: int, order_data: dict):
    with tracer.start_as_current_span("process_user_order") as span:
        span.set_attribute("user.id", user_id)
        span.set_attribute("order.total", order_data.get("total", 0))
        
        # Business logic here
        result = validate_order(user_id, order_data)
        span.set_attribute("order.valid", result.is_valid)
        
        return result

def validate_order(user_id: int, order_data: dict):
    with tracer.start_as_current_span("validate_order") as span:
        # Validation logic
        span.add_event("order_validation_started")
        
        # Simulate validation steps
        is_valid = len(order_data.get("items", [])) > 0
        span.set_attribute("validation.items_count", len(order_data.get("items", [])))
        
        span.add_event("order_validation_completed")
        return type('Result', (), {'is_valid': is_valid})()

  

# observability/fluent-bit-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: fluent-bit-config
  namespace: observability
  labels:
    k8s-app: fluent-bit
data:
  fluent-bit.conf: |
    [SERVICE]
        Daemon Off
        Flush 1
        Log_Level info
        Parsers_File parsers.conf
        HTTP_Server On
        HTTP_Listen 0.0.0.0
        HTTP_Port 2020
    
    [INPUT]
        Name tail
        Path /var/log/containers/*.log
        Parser docker
        Tag kube.*
        Mem_Buf_Limit 50MB
        Skip_Long_Lines On
    
    [FILTER]
        Name kubernetes
        Match kube.*
        Merge_Log On
        Keep_Log Off
        K8S-Logging.Parser On
        K8S-Logging.Exclude On
    
    [FILTER]
        Name nest
        Match kube.*
        Operation nest
        Wildcard pod_name
        Nest_under kubernetes
        Remove_prefix pod_name
    
    [FILTER]
        Name modify
        Match kube.*
        Rename log message
        Rename stream log_stream
    
    [OUTPUT]
        Name loki
        Match kube.*
        Host loki.observability.svc.cluster.local
        Port 3100
        Labels job=fluent-bit, cluster=production
        Label_keys $kubernetes['namespace_name'],$kubernetes['pod_name'],$kubernetes['container_name']
        Remove_keys kubernetes,stream,docker
    
    [OUTPUT]
        Name es
        Match kube.*
        Host elasticsearch.observability.svc.cluster.local
        Port 9200
        Index fluent-bit
        Type flb_type
        Retry_Limit False

  parsers.conf: |
    [PARSER]
        Name docker
        Format json
        Time_Key time
        Time_Format %Y-%m-%dT%H:%M:%S.%LZ
        Time_Keep On
    
    [PARSER]
        Name json
        Format json
        Time_Key time
        Time_Format %Y-%m-%dT%H:%M:%S.%LZ
    
    [PARSER]
        Name regex
        Format regex
        Regex ^(?[^ ]+) (?stdout|stderr) (?[P|F]) (?.+)$
        Time_Key time
        Time_Format %Y-%m-%dT%H:%M:%S.%L%z

  

# gitops/observability-app.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: observability-stack
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/your-org/observability-as-code.git
    targetRevision: main
    path: kubernetes/observability
    helm:
      valueFiles:
        - values-production.yaml
      parameters:
        - name: global.clusterName
          value: "production-cluster"
        - name: prometheus.storage.size
          value: "100Gi"
        - name: loki.persistence.size
          value: "50Gi"
  
  destination:
    server: https://kubernetes.default.svc
    namespace: observability
  
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
      - ApplyOutOfSyncOnly=true
  
  ignoreDifferences:
    - group: apps
      kind: Deployment
      jqPathExpressions:
        - .spec.replicas

---
# kubernetes/observability/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
namespace: observability

resources:
  - namespace.yaml
  - prometheus-stack/
  - loki-stack/
  - jaeger/
  - grafana/
  - otel-collector/
  - alerts/
  - dashboards/

configMapGenerator:
  - name: observability-config
    files:
      - prometheus-rules.yaml
      - alertmanager-config.yaml
      - logging-pipelines.yaml

patchesStrategicMerge:
  - resource-limits-patch.yaml

---
# kubernetes/observability/alerts/critical-alerts.yaml
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: critical-alerts
  namespace: observability
spec:
  groups:
    - name: kubernetes-apps
      rules:
        - alert: HighErrorRate
          expr: |
            rate(http_requests_total{status=~"5.."}[5m]) * 100
            /
            rate(http_requests_total[5m]) > 10
          for: 2m
          labels:
            severity: critical
            team: platform
          annotations:
            summary: "High error rate detected"
            description: "Error rate is {{ $value }}% for service {{ $labels.service }}"
        
        - alert: PodCrashLooping
          expr: |
            rate(kube_pod_container_status_restarts_total[15m]) * 60 * 5 > 0
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: "Pod is crash looping"
            description: "Pod {{ $labels.pod }} in namespace {{ $labels.namespace }} is restarting frequently"

  

# slo/user-service-slo.yaml
apiVersion: sloth.slok.dev/v1
kind: PrometheusServiceLevel
metadata:
  name: user-service
  namespace: observability
spec:
  service: "user-service"
  labels:
    team: "user-platform"
    tier: "1"
  
  slos:
    - name: "availability"
      objective: 99.9
      description: "User service HTTP availability SLO"
      sli:
        events:
          errorQuery: sum(rate(http_request_duration_seconds_count{job="user-service", status=~"5.."}[{{.window}}]))
          totalQuery: sum(rate(http_request_duration_seconds_count{job="user-service"}[{{.window}}]))
      alerting:
        name: UserServiceAvailabilityWarning
        labels:
          severity: warning
          channel: "#alerts-platform"
        annotations:
          summary: "User service availability SLO warning"
          description: "User service availability is currently at {{.sli}}% (objective: 99.9%)"
        
        name: UserServiceAvailabilityCritical
        labels:
          severity: critical
          channel: "#alerts-critical"
        annotations:
          summary: "User service availability SLO critical"
          description: "User service availability is currently at {{.sli}}% (objective: 99.9%)"
    
    - name: "latency"
      objective: 99.5
      description: "User service API latency SLO"
      sli:
        events:
          errorQuery: |
            sum(rate(http_request_duration_seconds_bucket{job="user-service", le="0.5"}[{{.window}}]))
          totalQuery: sum(rate(http_request_duration_seconds_count{job="user-service"}[{{.window}}]))
      alerting:
        name: UserServiceLatencyWarning
        labels:
          severity: warning
        annotations:
          summary: "User service latency SLO warning"
        
        name: UserServiceLatencyCritical
        labels:
          severity: critical

---
# slo/slo-renderer-job.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: slo-renderer
  namespace: observability
spec:
  schedule: "*/5 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: sloth
            image: slok/sloth:latest
            args:
            - generate
            - -i
            - /slo/manifests
            - -o
            - /slo/generated
            - --label
            - sloth.slok.dev/role=generated
            volumeMounts:
            - name: slo-manifests
              mountPath: /slo/manifests
            - name: slo-generated
              mountPath: /slo/generated
          volumes:
          - name: slo-manifests
            configMap:
              name: slo-manifests
          - name: slo-generated
            emptyDir: {}
          restartPolicy: OnFailure

  

/**
 * Micro-Frontend Shell Application
 * Main container that orchestrates federated modules
 */

import React, { Suspense, useEffect, useState } from 'react';
import { BrowserRouter as Router, Routes, Route, Navigate } from 'react-router-dom';
import { createGlobalState } from 'react-hooks-global-state';
import { ErrorBoundary } from 'react-error-boundary';

// Global state management for cross-microfrontend communication
const { useGlobalState, setGlobalState } = createGlobalState({
  user: null,
  theme: 'light',
  notifications: [],
  cart: [],
  featureFlags: {}
});

// Federated module configuration
const federatedModules = {
  auth: {
    url: process.env.REACT_APP_AUTH_MF_URL,
    scope: 'auth',
    module: './AuthApp'
  },
  dashboard: {
    url: process.env.REACT_APP_DASHBOARD_MF_URL,
    scope: 'dashboard',
    module: './DashboardApp'
  },
  products: {
    url: process.env.REACT_APP_PRODUCTS_MF_URL,
    scope: 'products',
    module: './ProductsApp'
  },
  orders: {
    url: process.env.REACT_APP_ORDERS_MF_URL,
    scope: 'orders',
    module: './OrdersApp'
  }
};

// Dynamic module loader with error handling and retry logic
const createFederatedModuleLoader = (moduleConfig) => {
  return async () => {
    try {
      // Initialize the shared scope with current and shared modules
      await __webpack_init_sharing__('default');
      
      const container = window[moduleConfig.scope];
      
      // Initialize the container if it hasn't been initialized
      await container.init(__webpack_share_scopes__.default);
      
      const factory = await window[moduleConfig.scope].get(moduleConfig.module);
      const Module = factory();
      return Module;
    } catch (error) {
      console.error(`Failed to load module ${moduleConfig.scope}`, error);
      throw error;
    }
  };
};

// Lazy-loaded federated components
const AuthApp = React.lazy(createFederatedModuleLoader(federatedModules.auth));
const DashboardApp = React.lazy(createFederatedModuleLoader(federatedModules.dashboard));
const ProductsApp = React.lazy(createFederatedModuleLoader(federatedModules.products));
const OrdersApp = React.lazy(createFederatedModuleLoader(federatedModules.orders));

// Shell Application Component
const AppShell = () => {
  const [user] = useGlobalState('user');
  const [theme] = useGlobalState('theme');
  const [notifications] = useGlobalState('notifications');
  const [modulesLoaded, setModulesLoaded] = useState({});

  useEffect(() => {
    // Preload critical modules
    preloadCriticalModules();
    initializeAppShell();
  }, []);

  const preloadCriticalModules = async () => {
    try {
      await Promise.all([
        createFederatedModuleLoader(federatedModules.auth)(),
        createFederatedModuleLoader(federatedModules.dashboard)()
      ]);
      setModulesLoaded(prev => ({ ...prev, auth: true, dashboard: true }));
    } catch (error) {
      console.error('Failed to preload critical modules', error);
    }
  };

  const initializeAppShell = () => {
    // Initialize cross-cutting concerns
    initializeAnalytics();
    initializeErrorTracking();
    initializePerformanceMonitoring();
  };

  const ErrorFallback = ({ error, resetErrorBoundary }) => (
    <div className="error-fallback">
      <h2>Something went wrong</h2>
      <details>
        <summary>Error Details</summary>
        <pre>{error.message}</pre>
      </details>
      <button onClick={resetErrorBoundary}>Try again</button>
    </div>
  );

  return (
    <Router>
      <div className={`app-shell ${theme}`}>
        {/* Global Navigation */}
        <header className="app-header">
          <nav className="global-nav">
            <div className="nav-brand">MyComposableApp</div>
            <div className="nav-links">
              <a href="/dashboard">Dashboard</a>
              <a href="/products">Products</a>
              <a href="/orders">Orders</a>
            </div>
            <div className="nav-actions">
              <NotificationBell count={notifications.length} />
              <UserProfile user={user} />
            </div>
          </nav>
        </header>

        {/* Main Content Area */}
        <main className="app-main">
          <ErrorBoundary
            FallbackComponent={ErrorFallback}
            onReset={() => window.location.reload()}
          >
            <Suspense fallback={<LoadingSpinner />}>
              <Routes>
                <Route path="/" element={<Navigate to="/dashboard" replace />} />
                
                <Route 
                  path="/auth/*" 
                  element={
                    <MicroFrontendContainer>
                      <AuthApp 
                        onLogin={(userData) => setGlobalState('user', userData)}
                        onLogout={() => setGlobalState('user', null)}
                      />
                    </MicroFrontendContainer>
                  } 
                />
                
                <Route 
                  path="/dashboard/*" 
                  element={
                    <ProtectedRoute user={user}>
                      <MicroFrontendContainer>
                        <DashboardApp 
                          user={user}
                          onDataUpdate={(data) => handleDashboardUpdate(data)}
                        />
                      </MicroFrontendContainer>
                    </ProtectedRoute>
                  } 
                />
                
                <Route 
                  path="/products/*" 
                  element={
                    <ProtectedRoute user={user}>
                      <MicroFrontendContainer>
                        <ProductsApp 
                          user={user}
                          onAddToCart={(product) => handleAddToCart(product)}
                        />
                      </MicroFrontendContainer>
                    </ProtectedRoute>
                  } 
                />
                
                <Route 
                  path="/orders/*" 
                  element={
                    <ProtectedRoute user={user}>
                      <MicroFrontendContainer>
                        <OrdersApp 
                          user={user}
                          onOrderUpdate={(order) => handleOrderUpdate(order)}
                        />
                      </MicroFrontendContainer>
                    </ProtectedRoute>
                  } 
                />
                
                <Route path="*" element={<NotFound />} />
              </Routes>
            </Suspense>
          </ErrorBoundary>
        </main>

        {/* Global Footer */}
        <footer className="app-footer">
          <div className="footer-content">
            <span>&copy; 2025 MyComposableApp. All rights reserved.</span>
            <div className="footer-links">
              <a href="/privacy">Privacy</a>
              <a href="/terms">Terms</a>
              <a href="/support">Support</a>
            </div>
          </div>
        </footer>
      </div>
    </Router>
  );
};

// Supporting Components
const MicroFrontendContainer = ({ children, ...props }) => (
  <div className="microfrontend-container" data-testid="microfrontend-container">
    <ErrorBoundary 
      FallbackComponent={MicroFrontendErrorFallback}
      onReset={() => window.location.reload()}
    >
      <Suspense fallback={<ModuleLoadingSpinner />}>
        {React.cloneElement(children, props)}
      </Suspense>
    </ErrorBoundary>
  </div>
);

const ProtectedRoute = ({ user, children }) => {
  if (!user) {
    return <Navigate to="/auth/login" replace />;
  }
  return children;
};

const LoadingSpinner = () => (
  <div className="loading-spinner">
    <div className="spinner"></div>
    <p>Loading application...</p>
  </div>
);

const ModuleLoadingSpinner = () => (
  <div className="module-loading">
    <div className="spinner small"></div>
    <p>Loading module...</p>
  </div>
);

const MicroFrontendErrorFallback = ({ error }) => (
  <div className="microfrontend-error">
    <h3>Module temporarily unavailable</h3>
    <p>We're experiencing issues loading this section of the application.</p>
    <button onClick={() => window.location.reload()}>Retry</button>
  </div>
);

// Event handlers for cross-microfrontend communication
const handleAddToCart = (product) => {
  setGlobalState('cart', prev => [...prev, product]);
  // Emit cross-microfrontend event
  window.dispatchEvent(new CustomEvent('cart:itemAdded', { 
    detail: { product, timestamp: Date.now() } 
  }));
};

const handleDashboardUpdate = (data) => {
  // Update global state based on dashboard events
  if (data.userPreferences) {
    setGlobalState('theme', data.userPreferences.theme);
  }
};

const handleOrderUpdate = (order) => {
  // Notify other microfrontends about order updates
  window.dispatchEvent(new CustomEvent('orders:updated', { 
    detail: { order, timestamp: Date.now() } 
  }));
};

// Utility functions
const initializeAnalytics = () => {
  // Initialize analytics tracking
  console.log('Analytics initialized');
};

const initializeErrorTracking = () => {
  // Initialize error tracking service
  console.log('Error tracking initialized');
};

const initializePerformanceMonitoring = () => {
  // Initialize performance monitoring
  console.log('Performance monitoring initialized');
};

export default AppShell;

  

/**
 * High-Performance BFF Service in Go
 * Optimized for micro-frontend data needs with advanced patterns
 */

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"
	"sync"

	"github.com/gin-gonic/gin"
	"golang.org/x/sync/errgroup"
)

// BFFService represents the main backend-for-frontend service
type BFFService struct {
	router         *gin.Engine
	httpClient     *http.Client
	cache          Cache
	circuitBreaker *CircuitBreaker
	services       *ServiceRegistry
}

// ServiceRegistry manages downstream service configurations
type ServiceRegistry struct {
	userServiceURL    string
	productServiceURL string
	orderServiceURL   string
	inventoryServiceURL string
}

// Cache interface for different caching strategies
type Cache interface {
	Get(ctx context.Context, key string) ([]byte, error)
	Set(ctx context.Context, key string, value []byte, ttl time.Duration) error
	Delete(ctx context.Context, key string) error
}

// CircuitBreaker for resilient service communication
type CircuitBreaker struct {
	failures     int
	maxFailures  int
	resetTimeout time.Duration
	lastFailure  time.Time
	mutex        sync.RWMutex
}

// NewBFFService creates a new BFF service instance
func NewBFFService() *BFFService {
	service := &BFFService{
		router: gin.Default(),
		httpClient: &http.Client{
			Timeout: 10 * time.Second,
			Transport: &http.Transport{
				MaxIdleConns:        100,
				MaxIdleConnsPerHost: 20,
				IdleConnTimeout:     90 * time.Second,
			},
		},
		circuitBreaker: &CircuitBreaker{
			maxFailures:  5,
			resetTimeout: 30 * time.Second,
		},
		services: &ServiceRegistry{
			userServiceURL:     os.Getenv("USER_SERVICE_URL"),
			productServiceURL:  os.Getenv("PRODUCT_SERVICE_URL"),
			orderServiceURL:    os.Getenv("ORDER_SERVICE_URL"),
			inventoryServiceURL: os.Getenv("INVENTORY_SERVICE_URL"),
		},
	}

	// Initialize cache (Redis, in-memory, etc.)
	service.cache = NewRedisCache()

	// Setup middleware
	service.setupMiddleware()

	// Setup routes
	service.setupRoutes()

	return service
}

// setupMiddleware configures global middleware
func (s *BFFService) setupMiddleware() {
	s.router.Use(s.correlationMiddleware())
	s.router.Use(s.loggingMiddleware())
	s.router.Use(s.corsMiddleware())
	s.router.Use(s.rateLimitMiddleware())
	s.router.Use(s.circuitBreakerMiddleware())
}

// setupRoutes configures all BFF endpoints
func (s *BFFService) setupRoutes() {
	// Dashboard aggregation endpoint
	s.router.GET("/api/dashboard", s.getDashboardData)

	// Product catalog with inventory
	s.router.GET("/api/products", s.getProductsWithInventory)

	// User profile with recent orders
	s.router.GET("/api/user/:id/profile", s.getUserProfile)

	// Order creation with validation
	s.router.POST("/api/orders", s.createOrder)

	// Health check endpoint
	s.router.GET("/health", s.healthCheck)
}

// getDashboardData aggregates data from multiple services for the dashboard
func (s *BFFService) getDashboardData(c *gin.Context) {
	userID := c.GetString("userID")
	ctx := c.Request.Context()

	// Use errgroup for concurrent service calls
	g, ctx := errgroup.WithContext(ctx)

	var (
		userData     *UserData
		recentOrders []Order
		productStats *ProductStats
		notifications []Notification
	)

	// Fetch user data
	g.Go(func() error {
		data, err := s.fetchUserData(ctx, userID)
		if err != nil {
			return fmt.Errorf("failed to fetch user data: %w", err)
		}
		userData = data
		return nil
	})

	// Fetch recent orders
	g.Go(func() error {
		orders, err := s.fetchRecentOrders(ctx, userID)
		if err != nil {
			return fmt.Errorf("failed to fetch orders: %w", err)
		}
		recentOrders = orders
		return nil
	})

	// Fetch product statistics
	g.Go(func() error {
		stats, err := s.fetchProductStats(ctx)
		if err != nil {
			return fmt.Errorf("failed to fetch product stats: %w", err)
		}
		productStats = stats
		return nil
	})

	// Fetch notifications
	g.Go(func() error {
		notifs, err := s.fetchNotifications(ctx, userID)
		if err != nil {
			return fmt.Errorf("failed to fetch notifications: %w", err)
		}
		notifications = notifs
		return nil
	})

	// Wait for all goroutines to complete
	if err := g.Wait(); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error":   "Failed to fetch dashboard data",
			"details": err.Error(),
		})
		return
	}

	// Transform and aggregate data for frontend
	dashboardData := gin.H{
		"user":         userData,
		"recentOrders": recentOrders,
		"productStats": productStats,
		"notifications": notifications,
		"summary": s.generateDashboardSummary(userData, recentOrders, productStats),
		"lastUpdated": time.Now().UTC(),
	}

	c.JSON(http.StatusOK, dashboardData)
}

// getProductsWithInventory returns products with real-time inventory data
func (s *BFFService) getProductsWithInventory(c *gin.Context) {
	ctx := c.Request.Context()
	
	// Try cache first
	cacheKey := "products:with-inventory"
	if cached, err := s.cache.Get(ctx, cacheKey); err == nil {
		var products []Product
		if err := json.Unmarshal(cached, &products); err == nil {
			c.JSON(http.StatusOK, products)
			return
		}
	}

	// Fetch products and inventory concurrently
	g, ctx := errgroup.WithContext(ctx)

	var products []Product
	var inventory map[string]int

	g.Go(func() error {
		p, err := s.fetchProducts(ctx)
		if err != nil {
			return err
		}
		products = p
		return nil
	})

	g.Go(func() error {
		inv, err := s.fetchInventory(ctx)
		if err != nil {
			return err
		}
		inventory = inv
		return nil
	})

	if err := g.Wait(); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": "Failed to fetch product data",
		})
		return
	}

	// Enrich products with inventory data
	enrichedProducts := s.enrichProductsWithInventory(products, inventory)

	// Cache the result
	if data, err := json.Marshal(enrichedProducts); err == nil {
		s.cache.Set(ctx, cacheKey, data, 5*time.Minute) // Cache for 5 minutes
	}

	c.JSON(http.StatusOK, enrichedProducts)
}

// createOrder handles order creation with validation and orchestration
func (s *BFFService) createOrder(c *gin.Context) {
	var orderRequest OrderRequest
	if err := c.ShouldBindJSON(&orderRequest); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Invalid request format",
		})
		return
	}

	ctx := c.Request.Context()
	userID := c.GetString("userID")

	// Validate order
	if err := s.validateOrder(ctx, orderRequest, userID); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": err.Error(),
		})
		return
	}

	// Process order creation
	order, err := s.processOrderCreation(ctx, orderRequest, userID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": "Failed to create order",
		})
		return
	}

	c.JSON(http.StatusCreated, order)
}

// Service communication methods
func (s *BFFService) fetchUserData(ctx context.Context, userID string) (*UserData, error) {
	url := fmt.Sprintf("%s/users/%s", s.services.userServiceURL, userID)
	
	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		return nil, err
	}

	resp, err := s.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("user service returned status: %d", resp.StatusCode)
	}

	var userData UserData
	if err := json.NewDecoder(resp.Body).Decode(&userData); err != nil {
		return nil, err
	}

	return &userData, nil
}

func (s *BFFService) fetchRecentOrders(ctx context.Context, userID string) ([]Order, error) {
	url := fmt.Sprintf("%s/orders?user_id=%s&limit=5", s.services.orderServiceURL, userID)
	
	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		return nil, err
	}

	resp, err := s.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("order service returned status: %d", resp.StatusCode)
	}

	var orders []Order
	if err := json.NewDecoder(resp.Body).Decode(&orders); err != nil {
		return nil, err
	}

	return orders, nil
}

// Data transformation methods
func (s *BFFService) enrichProductsWithInventory(products []Product, inventory map[string]int) []Product {
	enriched := make([]Product, len(products))
	for i, product := range products {
		enriched[i] = product
		if stock, exists := inventory[product.ID]; exists {
			enriched[i].Inventory = stock
			enriched[i].InStock = stock > 0
		}
	}
	return enriched
}

func (s *BFFService) generateDashboardSummary(userData *UserData, orders []Order, stats *ProductStats) DashboardSummary {
	totalSpent := 0.0
	for _, order := range orders {
		totalSpent += order.Total
	}

	return DashboardSummary{
		TotalOrders:    len(orders),
		TotalSpent:     totalSpent,
		FavoriteCategory: s.calculateFavoriteCategory(orders),
		MemberSince:    userData.CreatedAt,
	}
}

// Middleware implementations
func (s *BFFService) correlationMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		correlationID := c.GetHeader("X-Correlation-ID")
		if correlationID == "" {
			correlationID = generateCorrelationID()
		}
		c.Set("correlationID", correlationID)
		c.Header("X-Correlation-ID", correlationID)
		c.Next()
	}
}

func (s *BFFService) circuitBreakerMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		if s.circuitBreaker.IsOpen() {
			c.JSON(http.StatusServiceUnavailable, gin.H{
				"error": "Service temporarily unavailable",
			})
			c.Abort()
			return
		}
		c.Next()
	}
}

// Start the BFF service
func (s *BFFService) Start(port string) error {
	log.Printf("Starting BFF service on port %s", port)
	return s.router.Run(":" + port)
}

// Data structures
type UserData struct {
	ID        string    `json:"id"`
	Name      string    `json:"name"`
	Email     string    `json:"email"`
	CreatedAt time.Time `json:"created_at"`
	Preferences UserPreferences `json:"preferences"`
}

type Order struct {
	ID     string  `json:"id"`
	Total  float64 `json:"total"`
	Status string  `json:"status"`
	Items  []OrderItem `json:"items"`
}

type Product struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	Price    float64 `json:"price"`
	Inventory int    `json:"inventory"`
	InStock  bool   `json:"in_stock"`
}

type DashboardSummary struct {
	TotalOrders      int       `json:"total_orders"`
	TotalSpent       float64   `json:"total_spent"`
	FavoriteCategory string    `json:"favorite_category"`
	MemberSince      time.Time `json:"member_since"`
}

// Utility functions
func generateCorrelationID() string {
	return fmt.Sprintf("corr-%d-%s", time.Now().UnixNano(), randomString(8))
}

func randomString(length int) string {
	// Implementation for random string generation
	return "random"
}

func main() {
	service := NewBFFService()
	if err := service.Start("8080"); err != nil {
		log.Fatal(err)
	}
}

  

/**
 * Advanced Cloudflare Worker: Edge-Native Application with AI, Caching, and Personalization
 * Demonstrates sophisticated patterns for production edge applications
 */

// Worker configuration with environment variables
const config = {
  // Cache configuration
  defaultCacheTtl: 3600, // 1 hour
  staleWhileRevalidate: 7200, // 2 hours
  personalizationTtl: 300, // 5 minutes for user-specific content
  
  // AI/ML endpoints for edge inference
  aiEndpoints: {
    sentiment: 'https://api.example.com/v1/sentiment',
    recommendation: 'https://api.example.com/v1/recommend',
    imageProcessing: 'https://api.example.com/v1/process-image'
  },
  
  // Origin fallback configuration
  origins: {
    primary: 'https://origin.example.com',
    secondary: 'https://backup-origin.example.com',
    static: 'https://static-cdn.example.com'
  }
};

// Edge cache with sophisticated strategies
class EdgeCache {
  constructor() {
    this.cache = caches.default;
  }

  async get(key, options = {}) {
    const cacheKey = this.generateCacheKey(key, options);
    let response = await this.cache.match(cacheKey);
    
    if (!response && options.staleWhileRevalidate) {
      // Implement stale-while-revalidate pattern
      response = await this.handleStaleWhileRevalidate(cacheKey, options);
    }
    
    return response;
  }

  async set(key, response, options = {}) {
    const cacheKey = this.generateCacheKey(key, options);
    const cacheResponse = new Response(response.body, response);
    
    // Set cache control headers
    cacheResponse.headers.set('Cache-Control', 
      `public, max-age=${options.ttl || config.defaultCacheTtl}, 
       stale-while-revalidate=${options.staleWhileRevalidate || config.staleWhileRevalidate}`
    );
    
    if (options.tags) {
      cacheResponse.headers.set('Edge-Cache-Tags', options.tags.join(','));
    }
    
    await this.cache.put(cacheKey, cacheResponse);
  }

  async handleStaleWhileRevalidate(cacheKey, options) {
    // Return stale content while fetching fresh data in background
    const staleResponse = await this.getStaleVersion(cacheKey);
    if (staleResponse) {
      // Trigger async revalidation
      this.revalidateCache(cacheKey, options);
      return staleResponse;
    }
    return null;
  }

  generateCacheKey(key, options) {
    // Generate cache key with variations for personalization, geo, etc.
    const variations = {
      geo: options.geo || 'global',
      user: options.userId ? `user:${options.userId}` : 'anonymous',
      device: options.deviceType || 'desktop'
    };
    
    return `${key}-${Object.values(variations).join('-')}`;
  }
}

// AI-powered personalization at the edge
class EdgeAI {
  constructor() {
    this.models = new Map();
  }

  async personalizeContent(request, userContext) {
    // Real-time content personalization using edge AI
    const features = this.extractUserFeatures(request, userContext);
    
    // Use cached model inference when possible
    const personalizationKey = `personalize:${userContext.userId}`;
    let personalized = await this.getCachedPersonalization(personalizationKey);
    
    if (!personalized) {
      personalized = await this.generatePersonalization(features);
      await this.cachePersonalization(personalizationKey, personalized);
    }
    
    return personalized;
  }

  async generatePersonalization(features) {
    // Simple edge AI for demonstration - in production, use pre-trained models
    const recommendations = {
      layout: features.device === 'mobile' ? 'compact' : 'expanded',
      content: this.selectContentBasedOnInterests(features.interests),
      offers: this.generatePersonalizedOffers(features),
      ui: this.adaptUI(features.preferences)
    };
    
    return recommendations;
  }

  extractUserFeatures(request, userContext) {
    const geo = request.cf;
    return {
      userId: userContext.userId,
      location: {
        country: geo.country,
        city: geo.city,
        timezone: geo.timezone
      },
      device: this.detectDeviceType(request),
      interests: userContext.interests || [],
      preferences: userContext.preferences || {},
      behavior: this.analyzeUserBehavior(userContext.history)
    };
  }

  detectDeviceType(request) {
    const ua = request.headers.get('user-agent') || '';
    if (ua.includes('Mobile')) return 'mobile';
    if (ua.includes('Tablet')) return 'tablet';
    return 'desktop';
  }
}

// Main worker handler with advanced routing and middleware
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);
    const cache = new EdgeCache();
    const ai = new EdgeAI();
    
    // Apply middleware pipeline
    const response = await this.applyMiddleware(request, [
      this.rateLimiting,
      this.botDetection,
      this.geoRouting,
      this.userIdentification,
      this.contentOptimization
    ]);
    
    if (response) return response; // Middleware handled the request

    // Route-based handling
    const router = new EdgeRouter();
    
    router.get('/api/*', async (req) => {
      return await this.handleAPIRequest(req, cache, ai);
    });
    
    router.get('/*', async (req) => {
      return await this.handlePageRequest(req, cache, ai);
    });
    
    router.post('/api/analyze', async (req) => {
      return await this.handleAIAnalysis(req, ai);
    });

    return await router.route(request);
  },

  async handleAPIRequest(request, cache, ai) {
    const cacheKey = `api:${request.url}`;
    const cached = await cache.get(cacheKey, { ttl: 60 }); // 1 minute cache for API
    
    if (cached) {
      return cached;
    }

    // Add edge-specific headers to origin request
    const originRequest = new Request(request);
    this.addEdgeHeaders(originRequest);
    
    const response = await fetch(originRequest);
    
    // Cache successful responses
    if (response.status === 200) {
      ctx.waitUntil(cache.set(cacheKey, response.clone(), { ttl: 60 }));
    }
    
    return response;
  },

  async handlePageRequest(request, cache, ai) {
    const userContext = this.extractUserContext(request);
    const personalization = await ai.personalizeContent(request, userContext);
    
    // Generate cache key with personalization factors
    const cacheKey = `page:${request.url}`;
    const cacheOptions = {
      userId: userContext.userId,
      geo: request.cf.country,
      deviceType: personalization.layout
    };
    
    let response = await cache.get(cacheKey, cacheOptions);
    
    if (!response) {
      // Fetch from origin with personalization headers
      const originRequest = new Request(request);
      originRequest.headers.set('X-Edge-Personalization', 
        JSON.stringify(personalization));
      
      response = await fetch(originRequest);
      
      if (response.status === 200) {
        // Apply edge transformations
        response = await this.applyEdgeTransformations(response, personalization);
        ctx.waitUntil(cache.set(cacheKey, response.clone(), {
          ttl: config.personalizationTtl,
          ...cacheOptions
        }));
      }
    }
    
    return response;
  },

  async handleAIAnalysis(request, ai) {
    // Edge AI processing for real-time analysis
    const body = await request.json();
    
    // Simple sentiment analysis at the edge
    const sentiment = await this.analyzeSentiment(body.text);
    const recommendations = await ai.generatePersonalization({
      interests: this.extractInterests(body.text),
      behavior: body.context
    });
    
    return new Response(JSON.stringify({
      sentiment,
      recommendations,
      processedAt: new Date().toISOString(),
      location: request.cf.city // Edge location where processing occurred
    }), {
      headers: { 'Content-Type': 'application/json' }
    });
  },

  async analyzeSentiment(text) {
    // Simplified edge sentiment analysis
    // In production, use pre-trained models or call edge AI services
    const positiveWords = ['good', 'great', 'excellent', 'amazing', 'love'];
    const negativeWords = ['bad', 'terrible', 'awful', 'hate', 'disappointing'];
    
    const words = text.toLowerCase().split(/\W+/);
    const positive = words.filter(word => positiveWords.includes(word)).length;
    const negative = words.filter(word => negativeWords.includes(word)).length;
    
    if (positive > negative) return 'positive';
    if (negative > positive) return 'negative';
    return 'neutral';
  },

  // Middleware functions
  async rateLimiting(request) {
    const clientIP = request.headers.get('cf-connecting-ip');
    const rateLimitKey = `rate_limit:${clientIP}`;
    
    // Implement token bucket rate limiting
    const limit = await env.KV.get(rateLimitKey);
    if (limit && parseInt(limit) > 100) { // 100 requests per minute
      return new Response('Rate limit exceeded', { status: 429 });
    }
    
    // Increment counter
    ctx.waitUntil(env.KV.put(rateLimitKey, (parseInt(limit) || 0) + 1, {
      expirationTtl: 60
    }));
    
    return null;
  },

  async botDetection(request) {
    const ua = request.headers.get('user-agent') || '';
    const knownBots = ['bot', 'crawler', 'spider', 'scraper'];
    
    if (knownBots.some(bot => ua.toLowerCase().includes(bot))) {
      // Serve simplified content to bots
      return this.serveBotOptimizedContent(request);
    }
    
    return null;
  },

  addEdgeHeaders(request) {
    // Add edge computing context to origin requests
    request.headers.set('X-Edge-Location', request.cf.city);
    request.headers.set('X-Edge-Region', request.cf.region);
    request.headers.set('X-Edge-ASN', request.cf.asn);
    request.headers.set('X-Edge-Request-ID', generateRequestId());
  },

  applyEdgeTransformations(response, personalization) {
    // Transform origin response with edge-specific optimizations
    // This could include HTML rewriting, CSS inlining, image optimization, etc.
    return response;
  }
};

// Simple edge router for clean request handling
class EdgeRouter {
  constructor() {
    this.routes = [];
  }

  get(path, handler) {
    this.routes.push({ method: 'GET', path, handler });
  }

  post(path, handler) {
    this.routes.push({ method: 'POST', path, handler });
  }

  async route(request) {
    const url = new URL(request.url);
    
    for (const route of this.routes) {
      if (request.method === route.method && this.matchPath(route.path, url.pathname)) {
        return await route.handler(request);
      }
    }
    
    return new Response('Not found', { status: 404 });
  }

  matchPath(routePath, requestPath) {
    // Simple path matching - extend for complex routing
    if (routePath.includes('*')) {
      const basePath = routePath.replace('*', '');
      return requestPath.startsWith(basePath);
    }
    return routePath === requestPath;
  }
}

// Utility function to generate unique request IDs
function generateRequestId() {
  return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}

  

/**
 * Advanced AWS Lambda@Edge Functions
 * Comprehensive examples for viewer request, origin request, and response transformations
 */

// Lambda@Edge for viewer request manipulation
exports.viewerRequestHandler = async (event, context) => {
  const request = event.Records[0].cf.request;
  const headers = request.headers;
  
  // Advanced A/B testing at the edge
  const abTestVariant = determineAbTestVariant(request);
  if (abTestVariant) {
    request.uri = applyAbTestRouting(request.uri, abTestVariant);
  }
  
  // Geo-based content routing
  const countryCode = getCountryCode(headers);
  if (shouldRouteByGeo(countryCode)) {
    request.uri = applyGeoRouting(request.uri, countryCode);
  }
  
  // Device detection and optimization
  const deviceType = detectDeviceType(headers);
  request.headers['x-device-type'] = [{ key: 'X-Device-Type', value: deviceType }];
  
  // Bot traffic management
  if (isBotTraffic(headers)) {
    return serveBotOptimizedResponse(request);
  }
  
  // Rate limiting implementation
  if (await isRateLimited(request)) {
    return generateRateLimitResponse();
  }
  
  return request;
};

// Lambda@Edge for origin request customization
exports.originRequestHandler = async (event, context) => {
  const request = event.Records[0].cf.request;
  
  // Dynamic origin selection based on various factors
  request.origin = selectOptimalOrigin(request);
  
  // Header manipulation for origin
  enhanceOriginHeaders(request);
  
  // Request transformation based on edge logic
  if (shouldTransformRequest(request)) {
    transformRequestForOrigin(request);
  }
  
  // Cache key normalization
  normalizeCacheKey(request);
  
  return request;
};

// Lambda@Edge for origin response processing
exports.originResponseHandler = async (event, context) => {
  const response = event.Records[0].cf.response;
  const request = event.Records[0].cf.request;
  
  // Response optimization at the edge
  if (shouldOptimizeResponse(request, response)) {
    optimizeResponse(response);
  }
  
  // Security headers injection
  injectSecurityHeaders(response);
  
  // Personalization based on user context
  if (canPersonalizeResponse(request)) {
    await personalizeResponse(response, request);
  }
  
  // Error handling and custom error pages
  if (isErrorResponse(response)) {
    return handleErrorResponse(response, request);
  }
  
  // Cache control optimization
  optimizeCacheHeaders(response, request);
  
  return response;
};

// Lambda@Edge for viewer response manipulation
exports.viewerResponseHandler = async (event, context) => {
  const response = event.Records[0].cf.response;
  
  // Final response tweaks before reaching user
  if (response.status === '200') {
    addPerformanceHeaders(response);
    implementSecurityPolicies(response);
  }
  
  return response;
};

// Helper functions for Lambda@Edge
function determineAbTestVariant(request) {
  // Implement consistent A/B testing logic
  const userId = extractUserId(request);
  const testName = getAbTestName(request);
  
  if (!userId || !testName) return null;
  
  // Consistent hashing for stable assignments
  const hash = simpleHash(userId + testName);
  return hash % 2 === 0 ? 'A' : 'B';
}

function selectOptimalOrigin(request) {
  const headers = request.headers;
  const geo = getGeoFromHeaders(headers);
  const device = getDeviceType(headers);
  
  // Multi-origin routing logic
  if (isStaticAsset(request.uri)) {
    return {
      custom: {
        domainName: 'static-cdn.example.com',
        port: 443,
        protocol: 'https',
        path: '/assets',
        sslProtocols: ['TLSv1.2'],
        readTimeout: 30
      }
    };
  } else if (shouldUseRegionalOrigin(geo)) {
    return {
      custom: {
        domainName: `us-west-2.origin.example.com`,
        port: 443,
        protocol: 'https',
        path: '',
        sslProtocols: ['TLSv1.2'],
        readTimeout: 30
      }
    };
  }
  
  // Default origin
  return {
    custom: {
      domainName: 'primary.origin.example.com',
      port: 443,
      protocol: 'https',
      path: '',
      sslProtocols: ['TLSv1.2'],
      readTimeout: 30
    }
  };
}

function optimizeResponse(response) {
  // Implement response optimization strategies
  const headers = response.headers;
  
  // Brotli compression support
  if (supportsBrotli(headers)) {
    headers['content-encoding'] = [{ key: 'Content-Encoding', value: 'br' }];
  }
  
  // Image optimization
  if (isImageResponse(headers)) {
    optimizeImageHeaders(headers);
  }
  
  // CSS/JS optimization
  if (isTextResponse(headers)) {
    implementResourceHints(headers);
  }
}

async function personalizeResponse(response, request) {
  // Personalize content at the edge
  const userContext = extractUserContext(request);
  const personalizationData = await fetchPersonalization(userContext);
  
  if (personalizationData && response.body) {
    const personalizedBody = applyPersonalization(response.body, personalizationData);
    response.body = personalizedBody;
    response.headers['content-length'] = [
      { key: 'Content-Length', value: personalizedBody.length.toString() }
    ];
  }
}

function injectSecurityHeaders(response) {
  // Comprehensive security headers
  const headers = response.headers;
  
  headers['strict-transport-security'] = [
    { key: 'Strict-Transport-Security', value: 'max-age=31536000; includeSubDomains' }
  ];
  
  headers['x-content-type-options'] = [
    { key: 'X-Content-Type-Options', value: 'nosniff' }
  ];
  
  headers['x-frame-options'] = [
    { key: 'X-Frame-Options', value: 'DENY' }
  ];
  
  headers['x-xss-protection'] = [
    { key: 'X-XSS-Protection', value: '1; mode=block' }
  ];
  
  // Content Security Policy
  headers['content-security-policy'] = [
    { key: 'Content-Security-Policy', 
      value: "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';" }
  ];
}

// Utility functions
function getCountryCode(headers) {
  const cloudfrontViewerCountry = headers['cloudfront-viewer-country'];
  return cloudfrontViewerCountry ? cloudfrontViewerCountry[0].value : 'US';
}

function detectDeviceType(headers) {
  const userAgent = headers['user-agent'] ? headers['user-agent'][0].value : '';
  if (/mobile/i.test(userAgent)) return 'mobile';
  if (/tablet/i.test(userAgent)) return 'tablet';
  return 'desktop';
}

function isBotTraffic(headers) {
  const userAgent = headers['user-agent'] ? headers['user-agent'][0].value : '';
  const botPatterns = [/bot/, /crawler/, /spider/, /scraper/, /monitoring/];
  return botPatterns.some(pattern => pattern.test(userAgent.toLowerCase()));
}

function simpleHash(str) {
  let hash = 0;
  for (let i = 0; i < str.length; i++) {
    const char = str.charCodeAt(i);
    hash = ((hash << 5) - hash) + char;
    hash = hash & hash; // Convert to 32-bit integer
  }
  return Math.abs(hash);
}