defmodule Foundation.Telemetry do
  @moduledoc """
  Enhanced telemetry system for Foundation OS.
  Provides unified observability across all system layers.
  """
  
  @typedoc "Telemetry event name as hierarchical path"
  @type event_name :: [atom()]
  
  @typedoc "Numeric measurements"
  @type measurements :: %{atom() => number()}
  
  @typedoc "Event metadata and tags"
  @type metadata :: %{
    # Correlation IDs
    trace_id: String.t() | nil,
    span_id: String.t() | nil,
    request_id: String.t() | nil,
    
    # Entity identification
    agent_id: String.t() | nil,
    coordination_id: String.t() | nil,
    program_id: String.t() | nil,
    
    # Context information
    layer: :foundation | :foundation_jido | :dspex,
    node: atom(),
    environment: String.t(),
    
    # Custom metadata
    tags: [atom()],
    custom: map()
  }
  
  @doc """
  Execute telemetry event with enhanced metadata.
  """
  @spec execute(event_name(), measurements(), metadata()) :: :ok
  def execute(event_name, measurements \\ %{}, metadata \\ %{}) do
    enhanced_metadata = enrich_metadata(metadata)
    :telemetry.execute(event_name, measurements, enhanced_metadata)
  end
  
  @doc """
  Start a distributed trace span.
  """
  @spec start_span(String.t(), metadata()) :: String.t()
  def start_span(operation_name, metadata \\ %{}) do
    span_id = generate_span_id()
    trace_id = metadata[:trace_id] || generate_trace_id()
    
    execute([:foundation, :span, :start], %{timestamp: System.monotonic_time()}, %{
      span_id: span_id,
      trace_id: trace_id,
      operation: operation_name,
      parent_span: metadata[:span_id]
    })
    
    Process.put(:current_span, span_id)
    Process.put(:current_trace, trace_id)
    span_id
  end
  
  @doc """
  End current span and record duration.
  """
  @spec end_span(map()) :: :ok
  def end_span(additional_metadata \\ %{}) do
    case {Process.get(:current_span), Process.get(:current_trace)} do
      {span_id, trace_id} when not is_nil(span_id) ->
        start_time = get_span_start_time(span_id)
        duration = System.monotonic_time() - start_time
        
        execute([:foundation, :span, :end], %{duration: duration}, Map.merge(%{
          span_id: span_id,
          trace_id: trace_id
        }, additional_metadata))
        
        Process.delete(:current_span)
        :ok
      _ ->
        :ok
    end
  end
  
  @doc """
  Record metric with automatic aggregation.
  """
  @spec record_metric(String.t(), number(), map()) :: :ok
  def record_metric(metric_name, value, tags \\ %{}) do
    execute([:foundation, :metric], %{value: value}, %{
      metric: metric_name,
      tags: tags,
      timestamp: System.system_time(:millisecond)
    })
  end
  
  # Internal functions
  defp enrich_metadata(metadata) do
    base_metadata = %{
      node: Node.self(),
      timestamp: System.system_time(:millisecond),
      trace_id: Process.get(:current_trace),
      span_id: Process.get(:current_span)
    }
    
    Map.merge(base_metadata, metadata)
  end
  
  defp generate_trace_id, do: Base.encode16(:crypto.strong_rand_bytes(16))
  defp generate_span_id, do: Base.encode16(:crypto.strong_rand_bytes(8))
  
  # ... additional helper functions
end

# Foundation Layer Events
[:foundation, :process_registry, :register, :start]
[:foundation, :process_registry, :register, :complete]
[:foundation, :process_registry, :lookup, :start]
[:foundation, :infrastructure, :circuit_breaker, :state_change]
[:foundation, :infrastructure, :rate_limiter, :throttled]

# FoundationJido Integration Events
[:foundation_jido, :agent, :registration, :start]
[:foundation_jido, :agent, :registration, :complete]
[:foundation_jido, :signal, :dispatch, :start]
[:foundation_jido, :signal, :dispatch, :complete]
[:foundation_jido, :coordination, :auction, :start]
[:foundation_jido, :coordination, :auction, :bid_received]
[:foundation_jido, :coordination, :auction, :complete]

# DSPEx ML Events
[:dspex, :program, :execution, :start]
[:dspex, :program, :execution, :complete]
[:dspex, :optimization, :iteration, :start]
[:dspex, :optimization, :iteration, :complete]
[:dspex, :coordination, :multi_agent, :start]
[:dspex, :coordination, :multi_agent, :agent_result]
[:dspex, :coordination, :multi_agent, :complete]

# Cross-Layer Events
[:foundation_os, :request, :start]           # Full request lifecycle
[:foundation_os, :request, :complete]
[:foundation_os, :error, :occurred]          # Unified error tracking
[:foundation_os, :performance, :degradation] # Performance issues

# lib/foundation/telemetry/foundation_collector.ex
defmodule Foundation.Telemetry.FoundationCollector do
  @moduledoc """
  Collects telemetry specific to Foundation layer services.
  """
  
  use GenServer
  alias Foundation.Telemetry
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(_opts) do
    # Attach to Foundation-specific events
    events = [
      [:foundation, :process_registry, :register],
      [:foundation, :process_registry, :lookup],
      [:foundation, :infrastructure, :circuit_breaker],
      [:foundation, :infrastructure, :rate_limiter]
    ]
    
    :telemetry.attach_many("foundation-collector", events, &handle_event/4, %{})
    
    {:ok, %{metrics: %{}, aggregations: %{}}}
  end
  
  def handle_event([:foundation, :process_registry, :register], measurements, metadata, _config) do
    # Track process registration patterns
    Telemetry.record_metric("foundation.process_registry.registrations", 1, %{
      namespace: metadata[:namespace],
      process_type: metadata[:process_type]
    })
    
    # Track registration latency
    if measurements[:duration] do
      Telemetry.record_metric("foundation.process_registry.registration_duration", 
                             measurements[:duration], %{namespace: metadata[:namespace]})
    end
  end
  
  def handle_event([:foundation, :infrastructure, :circuit_breaker], measurements, metadata, _config) do
    case metadata[:state_change] do
      {:closed, :open} ->
        Telemetry.record_metric("foundation.circuit_breaker.opened", 1, %{
          name: metadata[:circuit_breaker],
          reason: metadata[:reason]
        })
      
      {:open, :closed} ->
        Telemetry.record_metric("foundation.circuit_breaker.closed", 1, %{
          name: metadata[:circuit_breaker]
        })
      
      _ -> :ok
    end
  end
  
  # ... additional event handlers
end

# lib/foundation_jido/telemetry/integration_collector.ex
defmodule FoundationJido.Telemetry.IntegrationCollector do
  @moduledoc """
  Collects telemetry for Jido integration layer.
  Tracks agent coordination and multi-agent workflows.
  """
  
  use GenServer
  alias Foundation.Telemetry
  
  def handle_event([:foundation_jido, :agent, :registration], measurements, metadata, _config) do
    # Track agent registration success rate
    Telemetry.record_metric("foundation_jido.agent.registrations", 1, %{
      success: metadata[:success],
      agent_type: metadata[:agent_type],
      capabilities: length(metadata[:capabilities] || [])
    })
    
    # Track agent startup time
    if measurements[:startup_duration] do
      Telemetry.record_metric("foundation_jido.agent.startup_duration",
                             measurements[:startup_duration], %{
        agent_type: metadata[:agent_type]
      })
    end
  end
  
  def handle_event([:foundation_jido, :coordination, :auction], measurements, metadata, _config) do
    case metadata[:phase] do
      :start ->
        # Track auction initiation
        Telemetry.record_metric("foundation_jido.auction.started", 1, %{
          resource_type: metadata[:resource_type],
          participant_count: metadata[:participant_count]
        })
      
      :bid_received ->
        # Track bid patterns
        Telemetry.record_metric("foundation_jido.auction.bids", 1, %{
          auction_id: metadata[:auction_id],
          bid_value: measurements[:bid_value]
        })
      
      :complete ->
        # Track auction outcomes
        Telemetry.record_metric("foundation_jido.auction.completed", 1, %{
          success: metadata[:success],
          winner_count: metadata[:winner_count],
          total_duration: measurements[:duration]
        })
    end
  end
  
  def handle_event([:foundation_jido, :signal, :dispatch], measurements, metadata, _config) do
    # Track signal dispatch patterns and performance
    Telemetry.record_metric("foundation_jido.signal.dispatches", 1, %{
      adapter: metadata[:adapter],
      success: metadata[:success],
      target_type: metadata[:target_type]
    })
    
    if measurements[:duration] do
      Telemetry.record_metric("foundation_jido.signal.dispatch_duration",
                             measurements[:duration], %{
        adapter: metadata[:adapter]
      })
    end
    
    # Track dispatch failures for alerting
    if not metadata[:success] do
      Telemetry.record_metric("foundation_jido.signal.dispatch_failures", 1, %{
        adapter: metadata[:adapter],
        error_category: metadata[:error_category]
      })
    end
  end
end

# lib/dspex/telemetry/ml_collector.ex
defmodule DSPEx.Telemetry.MLCollector do
  @moduledoc """
  Collects ML-specific telemetry for DSPEx operations.
  Tracks optimization progress, model performance, and coordination effectiveness.
  """
  
  use GenServer
  alias Foundation.Telemetry
  
  def handle_event([:dspex, :program, :execution], measurements, metadata, _config) do
    case metadata[:phase] do
      :start ->
        # Track program execution patterns
        Telemetry.record_metric("dspex.program.executions", 1, %{
          program_type: metadata[:program_type],
          signature_complexity: metadata[:signature_complexity]
        })
      
      :complete ->
        # Track execution performance
        Telemetry.record_metric("dspex.program.execution_duration",
                               measurements[:duration], %{
          program_type: metadata[:program_type],
          success: metadata[:success]
        })
        
        # Track output quality metrics
        if metadata[:output_quality] do
          Telemetry.record_metric("dspex.program.output_quality",
                                 metadata[:output_quality], %{
            program_id: metadata[:program_id]
          })
        end
    end
  end
  
  def handle_event([:dspex, :optimization, :iteration], measurements, metadata, _config) do
    case metadata[:phase] do
      :start ->
        # Track optimization iteration start
        Telemetry.record_metric("dspex.optimization.iterations", 1, %{
          strategy: metadata[:strategy],
          iteration: metadata[:iteration]
        })
      
      :complete ->
        # Track optimization progress
        Telemetry.record_metric("dspex.optimization.iteration_duration",
                               measurements[:duration], %{
          strategy: metadata[:strategy]
        })
        
        # Track convergence metrics
        if measurements[:performance_score] do
          Telemetry.record_metric("dspex.optimization.performance_score",
                                 measurements[:performance_score], %{
            strategy: metadata[:strategy],
            iteration: metadata[:iteration]
          })
        end
        
        if measurements[:convergence_rate] do
          Telemetry.record_metric("dspex.optimization.convergence_rate",
                                 measurements[:convergence_rate], %{
            strategy: metadata[:strategy]
          })
        end
    end
  end
  
  def handle_event([:dspex, :coordination, :multi_agent], measurements, metadata, _config) do
    case metadata[:phase] do
      :start ->
        # Track multi-agent coordination initiation
        Telemetry.record_metric("dspex.coordination.multi_agent_start", 1, %{
          agent_count: metadata[:agent_count],
          coordination_type: metadata[:coordination_type]
        })
      
      :agent_result ->
        # Track individual agent contributions
        Telemetry.record_metric("dspex.coordination.agent_contributions", 1, %{
          agent_id: metadata[:agent_id],
          contribution_quality: measurements[:quality_score]
        })
      
      :complete ->
        # Track overall coordination effectiveness
        Telemetry.record_metric("dspex.coordination.multi_agent_complete", 1, %{
          success: metadata[:success],
          final_score: measurements[:final_performance],
          coordination_duration: measurements[:duration]
        })
        
        # Track coordination efficiency
        if measurements[:efficiency_score] do
          Telemetry.record_metric("dspex.coordination.efficiency",
                                 measurements[:efficiency_score], %{
            agent_count: metadata[:agent_count],
            coordination_type: metadata[:coordination_type]
          })
        end
    end
  end
end

# lib/foundation/telemetry/distributed_tracer.ex
defmodule Foundation.Telemetry.DistributedTracer do
  @moduledoc """
  Implements distributed tracing across Foundation OS layers.
  Provides end-to-end visibility for complex multi-agent workflows.
  """
  
  alias Foundation.Telemetry
  
  @doc """
  Start a new distributed trace for a user request.
  """
  def start_request_trace(operation, metadata \\ %{}) do
    trace_id = Telemetry.generate_trace_id()
    span_id = Telemetry.start_span("request.#{operation}", %{
      trace_id: trace_id,
      layer: :foundation_os,
      operation_type: :user_request
    })
    
    Telemetry.execute([:foundation_os, :request, :start], %{
      timestamp: System.system_time(:millisecond)
    }, Map.merge(metadata, %{
      trace_id: trace_id,
      span_id: span_id,
      operation: operation
    }))
    
    {trace_id, span_id}
  end
  
  @doc """
  Create child span for layer-specific operations.
  """
  def create_child_span(operation, layer, metadata \\ %{}) do
    parent_trace = Process.get(:current_trace)
    parent_span = Process.get(:current_span)
    
    child_span = Telemetry.start_span("#{layer}.#{operation}", %{
      trace_id: parent_trace,
      parent_span: parent_span,
      layer: layer
    })
    
    {parent_trace, child_span}
  end
  
  @doc """
  Complete request trace with final metrics.
  """
  def complete_request_trace(trace_id, final_metadata \\ %{}) do
    Telemetry.execute([:foundation_os, :request, :complete], %{
      timestamp: System.system_time(:millisecond)
    }, Map.merge(final_metadata, %{
      trace_id: trace_id
    }))
    
    Telemetry.end_span(final_metadata)
  end
end

# Example: Multi-agent optimization request
defmodule DSPEx.OptimizationController do
  alias Foundation.Telemetry.DistributedTracer
  
  def optimize_with_coordination(program, training_data, opts) do
    # Start request trace
    {trace_id, _span} = DistributedTracer.start_request_trace("multi_agent_optimization", %{
      program_id: program.id,
      agent_count: opts[:agent_count]
    })
    
    try do
      # Foundation layer: Agent discovery
      {^trace_id, _} = DistributedTracer.create_child_span("agent_discovery", :foundation)
      agents = FoundationJido.Agent.find_agents_by_capability(:ml_optimization)
      Telemetry.end_span(%{agents_found: length(agents)})
      
      # FoundationJido layer: Coordination setup
      {^trace_id, _} = DistributedTracer.create_child_span("coordination_setup", :foundation_jido)
      coordination_spec = build_coordination_spec(program, opts)
      Telemetry.end_span(%{coordination_type: coordination_spec.type})
      
      # DSPEx layer: Multi-agent optimization
      {^trace_id, _} = DistributedTracer.create_child_span("multi_agent_optimization", :dspex)
      result = DSPEx.Coordination.optimize_with_agents(agents, program, training_data, coordination_spec)
      Telemetry.end_span(%{optimization_success: elem(result, 0) == :ok})
      
      # Complete request trace
      DistributedTracer.complete_request_trace(trace_id, %{
        request_success: elem(result, 0) == :ok,
        final_performance: get_performance_score(result)
      })
      
      result
    rescue
      exception ->
        DistributedTracer.complete_request_trace(trace_id, %{
          request_success: false,
          error: Exception.message(exception)
        })
        reraise exception, __STACKTRACE__
    end
  end
end

# System Health Metrics
foundation.process_registry.registration_rate     # Registrations per second
foundation.process_registry.lookup_latency        # Average lookup time
foundation.infrastructure.circuit_breaker.health  # % of circuit breakers healthy
foundation.infrastructure.error_rate              # Errors per minute

# Resource Utilization
foundation.memory.usage                           # Memory utilization %
foundation.cpu.usage                              # CPU utilization %
foundation.connections.active                     # Active connections count

# Agent Coordination Metrics
foundation_jido.agents.active_count               # Currently active agents
foundation_jido.coordination.success_rate         # % successful coordinations
foundation_jido.coordination.average_duration     # Average coordination time
foundation_jido.signal.dispatch_success_rate      # % successful signal dispatches

# Multi-Agent Efficiency
foundation_jido.auction.participation_rate        # % agents participating in auctions
foundation_jido.auction.fairness_score           # Distribution fairness metric
foundation_jido.coordination.resource_utilization # Efficiency of resource allocation

# ML Performance Metrics
dspex.optimization.convergence_rate               # % optimizations that converge
dspex.optimization.performance_improvement        # Average performance gain
dspex.program.execution_success_rate              # % successful program executions
dspex.coordination.multi_agent_efficiency         # Multi-agent vs single-agent performance

# Business Value Metrics
dspex.cost_per_optimization                       # Cost efficiency
dspex.time_to_convergence                         # Speed of optimization
dspex.model_accuracy_improvement                  # Quality improvements

# lib/foundation/telemetry/alerting.ex
defmodule Foundation.Telemetry.Alerting do
  @moduledoc """
  Intelligent alerting system based on telemetry data.
  Provides proactive alerting for system health and performance issues.
  """
  
  use GenServer
  alias Foundation.Telemetry
  
  # Alert rules configuration
  @alert_rules [
    # Foundation layer alerts
    %{
      name: "High Error Rate",
      metric: "foundation.error_rate",
      threshold: 0.05,  # 5% error rate
      window: :minute,
      severity: :warning
    },
    %{
      name: "Circuit Breaker Open",
      event: [:foundation, :infrastructure, :circuit_breaker],
      condition: &circuit_breaker_opened?/1,
      severity: :error
    },
    
    # FoundationJido layer alerts
    %{
      name: "Agent Coordination Failure",
      metric: "foundation_jido.coordination.success_rate",
      threshold: 0.8,   # Below 80% success rate
      window: :hour,
      severity: :warning
    },
    %{
      name: "Signal Dispatch Failures",
      metric: "foundation_jido.signal.dispatch_success_rate", 
      threshold: 0.9,   # Below 90% success rate
      window: :minute,
      severity: :error
    },
    
    # DSPEx layer alerts
    %{
      name: "Optimization Convergence Issues",
      metric: "dspex.optimization.convergence_rate",
      threshold: 0.7,   # Below 70% convergence rate
      window: :hour,
      severity: :warning
    },
    %{
      name: "Multi-Agent Coordination Inefficiency",
      metric: "dspex.coordination.efficiency",
      threshold: 0.6,   # Below 60% efficiency
      window: :hour,
      severity: :warning
    }
  ]
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(opts) do
    # Setup metric collection for alerting
    :timer.send_interval(30_000, self(), :check_alerts)  # Check every 30 seconds
    
    {:ok, %{
      alert_rules: @alert_rules,
      metric_buffer: %{},
      active_alerts: %{}
    }}
  end
  
  def handle_info(:check_alerts, state) do
    new_state = Enum.reduce(state.alert_rules, state, fn rule, acc_state ->
      check_alert_rule(rule, acc_state)
    end)
    
    {:noreply, new_state}
  end
  
  defp check_alert_rule(%{metric: metric, threshold: threshold} = rule, state) do
    current_value = get_metric_value(metric, rule[:window])
    
    cond do
      current_value > threshold and not Map.has_key?(state.active_alerts, rule.name) ->
        # Trigger new alert
        trigger_alert(rule, current_value)
        put_in(state, [:active_alerts, rule.name], %{
          triggered_at: DateTime.utc_now(),
          current_value: current_value
        })
      
      current_value <= threshold and Map.has_key?(state.active_alerts, rule.name) ->
        # Resolve existing alert
        resolve_alert(rule, current_value)
        Map.update!(state, :active_alerts, &Map.delete(&1, rule.name))
      
      true ->
        state
    end
  end
  
  defp trigger_alert(rule, current_value) do
    alert_data = %{
      name: rule.name,
      severity: rule.severity,
      metric: rule[:metric],
      threshold: rule[:threshold],
      current_value: current_value,
      timestamp: DateTime.utc_now()
    }
    
    # Send to telemetry for external alert systems
    Telemetry.execute([:foundation_os, :alert, :triggered], %{severity_level: severity_to_number(rule.severity)}, alert_data)
    
    # Send notifications (email, Slack, PagerDuty, etc.)
    send_alert_notification(alert_data)
  end
  
  defp resolve_alert(rule, current_value) do
    Telemetry.execute([:foundation_os, :alert, :resolved], %{}, %{
      name: rule.name,
      resolved_at: DateTime.utc_now(),
      final_value: current_value
    })
  end
  
  # ... additional implementation
end

# lib/foundation/telemetry/performance_monitor.ex
defmodule Foundation.Telemetry.PerformanceMonitor do
  @moduledoc """
  Continuous performance monitoring and baseline establishment.
  Tracks performance trends and detects degradation automatically.
  """
  
  use GenServer
  alias Foundation.Telemetry
  
  @performance_metrics [
    # Foundation performance baselines
    "foundation.process_registry.lookup_latency",
    "foundation.infrastructure.circuit_breaker.latency",
    
    # Integration layer performance
    "foundation_jido.agent.startup_duration", 
    "foundation_jido.coordination.duration",
    "foundation_jido.signal.dispatch_duration",
    
    # ML performance baselines
    "dspex.program.execution_duration",
    "dspex.optimization.iteration_duration",
    "dspex.coordination.multi_agent_duration"
  ]
  
  def collect_performance_baseline(duration \\ :hour) do
    baseline_data = Enum.map(@performance_metrics, fn metric ->
      {metric, collect_metric_statistics(metric, duration)}
    end)
    |> Map.new()
    
    # Store baseline for comparison
    store_performance_baseline(baseline_data)
    
    baseline_data
  end
  
  def detect_performance_degradation(current_metrics) do
    baseline = get_current_baseline()
    
    degradations = Enum.reduce(current_metrics, [], fn {metric, current_value}, acc ->
      case Map.get(baseline, metric) do
        nil -> acc  # No baseline for this metric
        baseline_stats ->
          if performance_degraded?(current_value, baseline_stats) do
            degradation = %{
              metric: metric,
              current: current_value,
              baseline_mean: baseline_stats.mean,
              baseline_p95: baseline_stats.p95,
              degradation_factor: current_value / baseline_stats.mean
            }
            [degradation | acc]
          else
            acc
          end
      end
    end)
    
    if length(degradations) > 0 do
      Telemetry.execute([:foundation_os, :performance, :degradation], %{
        degraded_metrics_count: length(degradations)
      }, %{
        degradations: degradations
      })
    end
    
    degradations
  end
  
  defp performance_degraded?(current_value, baseline_stats) do
    # Consider performance degraded if current value is more than 2x the baseline mean
    # or exceeds the 95th percentile by more than 50%
    current_value > baseline_stats.mean * 2.0 or 
    current_value > baseline_stats.p95 * 1.5
  end
  
  # ... additional implementation
end

# lib/foundation/telemetry/adaptive_sampler.ex
defmodule Foundation.Telemetry.AdaptiveSampler do
  @moduledoc """
  Adaptive sampling to reduce telemetry overhead while maintaining observability.
  Automatically adjusts sampling rates based on system load and error conditions.
  """
  
  use GenServer
  
  # Default sampling rates
  @base_sampling_rates %{
    # High frequency, low overhead events
    "foundation.process_registry.lookup" => 0.1,          # 10% sampling
    "foundation_jido.signal.dispatch" => 0.2,             # 20% sampling
    
    # Medium frequency events
    "foundation_jido.agent.registration" => 0.5,          # 50% sampling
    "dspex.program.execution" => 0.8,                     # 80% sampling
    
    # Low frequency, high value events
    "foundation_jido.coordination.auction" => 1.0,        # 100% sampling
    "dspex.optimization.iteration" => 1.0,                # 100% sampling
    "foundation_os.error.occurred" => 1.0                 # Always sample errors
  }
  
  def should_sample?(event_name, metadata \\ %{}) do
    base_rate = get_sampling_rate(event_name)
    adjusted_rate = adjust_sampling_rate(base_rate, event_name, metadata)
    
    :rand.uniform() <= adjusted_rate
  end
  
  defp adjust_sampling_rate(base_rate, event_name, metadata) do
    adjustments = [
      &error_boost/3,           # Increase sampling during errors
      &load_adjustment/3,       # Decrease sampling under high load
      &critical_path_boost/3    # Increase sampling for critical operations
    ]
    
    Enum.reduce(adjustments, base_rate, fn adjustment_fn, rate ->
      adjustment_fn.(rate, event_name, metadata)
    end)
    |> max(0.0)
    |> min(1.0)
  end
  
  defp error_boost(rate, _event_name, metadata) do
    # Increase sampling when errors are occurring
    if metadata[:error_context] or metadata[:retry_attempt] do
      min(rate * 2.0, 1.0)
    else
      rate
    end
  end
  
  defp load_adjustment(rate, _event_name, _metadata) do
    # Decrease sampling under high system load
    system_load = get_system_load()
    
    case system_load do
      load when load > 0.8 -> rate * 0.5    # High load: reduce sampling
      load when load > 0.6 -> rate * 0.7    # Medium load: slight reduction
      _ -> rate                              # Normal load: no adjustment
    end
  end
  
  defp critical_path_boost(rate, event_name, metadata) do
    # Increase sampling for critical business operations
    critical_patterns = [
      "dspex.coordination.multi_agent",
      "foundation_jido.coordination",
      "foundation_os.request"
    ]
    
    if Enum.any?(critical_patterns, &String.contains?(to_string(event_name), &1)) do
      min(rate * 1.5, 1.0)
    else
      rate
    end
  end
  
  # ... additional implementation
end

# lib/foundation/telemetry/prometheus_exporter.ex
defmodule Foundation.Telemetry.PrometheusExporter do
  @moduledoc """
  Exports Foundation OS telemetry to Prometheus format.
  Provides integration with Prometheus/Grafana monitoring stack.
  """
  
  use GenServer
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(opts) do
    # Setup Prometheus metrics
    setup_prometheus_metrics()
    
    # Attach to telemetry events
    :telemetry.attach_many("prometheus-exporter", telemetry_events(), &handle_telemetry_event/4, %{})
    
    {:ok, %{}}
  end
  
  defp setup_prometheus_metrics do
    # Foundation metrics
    :prometheus_counter.new([
      name: :foundation_process_registrations_total,
      help: "Total number of process registrations",
      labels: [:namespace, :process_type]
    ])
    
    :prometheus_histogram.new([
      name: :foundation_process_lookup_duration_seconds,
      help: "Process lookup duration",
      labels: [:namespace],
      buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0]
    ])
    
    # FoundationJido metrics
    :prometheus_gauge.new([
      name: :foundation_jido_active_agents,
      help: "Number of currently active agents",
      labels: [:agent_type]
    ])
    
    :prometheus_counter.new([
      name: :foundation_jido_coordinations_total,
      help: "Total number of agent coordinations",
      labels: [:coordination_type, :success]
    ])
    
    # DSPEx metrics
    :prometheus_histogram.new([
      name: :dspex_optimization_duration_seconds,
      help: "ML optimization duration",
      labels: [:strategy, :program_type],
      buckets: [1, 5, 10, 30, 60, 300, 600]  # seconds
    ])
    
    :prometheus_gauge.new([
      name: :dspex_optimization_performance_score,
      help: "Current optimization performance score",
      labels: [:program_id, :strategy]
    ])
  end
  
  def handle_telemetry_event([:foundation, :process_registry, :register], measurements, metadata, _config) do
    :prometheus_counter.inc(:foundation_process_registrations_total, [
      metadata[:namespace] || "default",
      metadata[:process_type] || "unknown"
    ])
    
    if measurements[:duration] do
      :prometheus_histogram.observe(:foundation_process_lookup_duration_seconds, [
        metadata[:namespace] || "default"
      ], measurements[:duration] / 1000)  # Convert to seconds
    end
  end
  
  def handle_telemetry_event([:foundation_jido, :coordination, :auction], measurements, metadata, _config) do
    success = if metadata[:success], do: "true", else: "false"
    
    :prometheus_counter.inc(:foundation_jido_coordinations_total, [
      metadata[:coordination_type] || "auction",
      success
    ])
  end
  
  def handle_telemetry_event([:dspex, :optimization, :iteration], measurements, metadata, _config) do
    if measurements[:duration] and metadata[:phase] == :complete do
      :prometheus_histogram.observe(:dspex_optimization_duration_seconds, [
        metadata[:strategy] || "unknown",
        metadata[:program_type] || "unknown"
      ], measurements[:duration] / 1000)
    end
    
    if measurements[:performance_score] do
      :prometheus_gauge.set(:dspex_optimization_performance_score, [
        metadata[:program_id] || "unknown",
        metadata[:strategy] || "unknown"
      ], measurements[:performance_score])
    end
  end
  
  # ... additional event handlers
end

# lib/foundation/telemetry/cloud_integrations.ex
defmodule Foundation.Telemetry.CloudIntegrations do
  @moduledoc """
  Integrations with cloud monitoring platforms.
  Supports AWS CloudWatch, Google Cloud Monitoring, Azure Monitor.
  """
  
  def send_to_cloudwatch(metrics) do
    # AWS CloudWatch integration
    namespace = "FoundationOS"
    
    metric_data = Enum.map(metrics, fn {name, value, tags} ->
      %{
        "MetricName" => name,
        "Value" => value,
        "Unit" => determine_unit(name),
        "Dimensions" => format_dimensions(tags),
        "Timestamp" => DateTime.utc_now() |> DateTime.to_iso8601()
      }
    end)
    
    ExAws.CloudWatch.put_metric_data(namespace, metric_data)
    |> ExAws.request()
  end
  
  def send_to_datadog(metrics) do
    # Datadog integration
    datadog_metrics = Enum.map(metrics, fn {name, value, tags} ->
      %{
        metric: "foundationos.#{name}",
        points: [[System.system_time(:second), value]],
        tags: format_datadog_tags(tags),
        type: determine_datadog_type(name)
      }
    end)
    
    HTTPoison.post(
      "https://api.datadoghq.com/api/v1/series",
      Jason.encode!(%{series: datadog_metrics}),
      [
        {"Content-Type", "application/json"},
        {"DD-API-KEY", Application.get_env(:foundation, :datadog_api_key)}
      ]
    )
  end
  
  # ... additional cloud integrations
end