// main.go
// Production-ready Go microservice instrumented with OpenTelemetry 1.20
// Exports metrics to Prometheus 2.50 and traces to OTel Collector
package main

import (
    \"context\"
    \"fmt\"
    \"log\"
    \"net/http\"
    \"os\"
    \"time\"

    \"go.opentelemetry.io/otel\"
    \"go.opentelemetry.io/otel/attribute\"
    \"go.opentelemetry.io/otel/exporters/prometheus\"
    \"go.opentelemetry.io/otel/metric\"
    \"go.opentelemetry.io/otel/propagation\"
    \"go.opentelemetry.io/otel/sdk/metric\"
    \"go.opentelemetry.io/otel/sdk/resource\"
    semconv \"go.opentelemetry.io/otel/semconv/v1.20.0\"
    \"go.opentelemetry.io/otel/trace\"
    \"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp\"
)

// Define custom metrics
var (
    requestCounter metric.Int64Counter
    requestLatency metric.Float64Histogram
)

func initMetrics(ctx context.Context) error {
    // Set up Prometheus exporter (compatible with Prometheus 2.50)
    promExporter, err := prometheus.New()
    if err != nil {
        return fmt.Errorf(\"failed to create Prometheus exporter: %w\", err)
    }

    // Set up resource with service metadata
    res, err := resource.New(ctx,
        resource.WithAttributes(
            semconv.ServiceName(\"payment-service\"),
            semconv.ServiceVersion(\"1.0.0\"),
            attribute.String(\"environment\", \"production\"),
        ),
    )
    if err != nil {
        return fmt.Errorf(\"failed to create resource: %w\", err)
    }

    // Set up meter provider with Prometheus exporter
    meterProvider := metric.NewMeterProvider(
        metric.WithReader(promExporter),
        metric.WithResource(res),
    )
    otel.SetMeterProvider(meterProvider)

    // Create meter and define custom metrics
    meter := otel.GetMeterProvider().Meter(\"payment-service\")
    requestCounter, err = meter.Int64Counter(
        \"http.requests.total\",
        metric.WithDescription(\"Total number of HTTP requests\"),
        metric.WithUnit(\"1\"),
    )
    if err != nil {
        return fmt.Errorf(\"failed to create request counter: %w\", err)
    }

    requestLatency, err = meter.Float64Histogram(
        \"http.request.duration\",
        metric.WithDescription(\"HTTP request latency in milliseconds\"),
        metric.WithUnit(\"ms\"),
        metric.WithExplicitBucketBoundaries(10, 50, 100, 200, 500, 1000, 2000),
    )
    if err != nil {
        return fmt.Errorf(\"failed to create latency histogram: %w\", err)
    }

    // Set up trace provider (send traces to OTel Collector)
    // Note: For brevity, we omit trace exporter setup here, but production would use OTLP gRPC exporter
    // to send traces to Jaeger or Grafana Tempo
    otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
        propagation.TraceContext{},
        propagation.Baggage{},
    ))

    log.Println(\"OpenTelemetry 1.20 metrics initialized successfully\")
    return nil
}

// HTTP handler with OTel instrumentation
func paymentHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    span := trace.SpanFromContext(ctx)
    span.SetAttributes(attribute.String(\"http.route\", \"/payment\"))

    start := time.Now()

    // Simulate business logic
    time.Sleep(50 * time.Millisecond)

    // Record metrics
    requestCounter.Add(ctx, 1, metric.WithAttributes(
        attribute.String(\"http.method\", r.Method),
        attribute.Int(\"http.status_code\", http.StatusOK),
    ))
    requestLatency.Record(ctx, float64(time.Since(start).Milliseconds()), metric.WithAttributes(
        attribute.String(\"http.method\", r.Method),
    ))

    span.End()
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, \"Payment processed successfully\")
}

func main() {
    ctx := context.Background()

    // Initialize OTel metrics
    if err := initMetrics(ctx); err != nil {
        log.Fatalf(\"Failed to initialize metrics: %v\", err)
    }

    // Wrap HTTP handler with OTel instrumentation
    wrappedHandler := otelhttp.NewHandler(
        http.HandlerFunc(paymentHandler),
        \"/payment\",
    )

    // Start Prometheus metrics endpoint (scraped by Prometheus 2.50)
    http.Handle(\"/metrics\", prometheus.New().Handler())
    http.Handle(\"/payment\", wrappedHandler)

    port := os.Getenv(\"PORT\")
    if port == \"\" {
        port = \"8080\"
    }

    log.Printf(\"Starting server on port %s\", port)
    if err := http.ListenAndServe(fmt.Sprintf(\":%s\", port), nil); err != nil {
        log.Fatalf(\"Server failed: %v\", err)
    }
}

# migrate_datadog_metrics.py
# Migrates Datadog custom metrics to OpenTelemetry 1.20 counters/gauges
# Uses Datadog API to fetch existing metrics, exports via OTel Python SDK
import os
import time
import logging
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.metrics_api import MetricsApi
from opentelemetry import metrics
from opentelemetry.exporter.prometheus import PrometheusMetricReader
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.resources import Resource
from opentelemetry.semconv.resource import ResourceAttributes

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Datadog API credentials (set via env vars)
DD_API_KEY = os.getenv(\"DD_API_KEY\")
DD_APP_KEY = os.getenv(\"DD_APP_KEY\")
DD_SITE = os.getenv(\"DD_SITE\", \"datadoghq.com\")

# OTel resource configuration
resource = Resource.create({
    ResourceAttributes.SERVICE_NAME: \"datadog-migrator\",
    ResourceAttributes.SERVICE_VERSION: \"1.0.0\",
    \"migration.source\": \"datadog\",
    \"migration.target\": \"opentelemetry\",
})

# Set up OTel MeterProvider with Prometheus exporter (compatible with Prometheus 2.50)
reader = PrometheusMetricReader()
provider = MeterProvider(resource=resource, metric_readers=[reader])
metrics.set_meter_provider(provider)

# Create OTel meter
meter = metrics.get_meter(\"datadog-migrator\")

# Cache for OTel metrics to avoid re-creating them
otel_metrics = {}

def init_datadog_client():
    \"\"\"Initialize Datadog API client\"\"\"
    config = Configuration()
    config.api_key[\"apiKeyAuth\"] = DD_API_KEY
    config.api_key[\"appKeyAuth\"] = DD_APP_KEY
    config.server_variables[\"site\"] = DD_SITE
    return ApiClient(config)

def fetch_datadog_metrics(client, hours=24):
    \"\"\"Fetch custom metrics from Datadog over the last N hours\"\"\"
    api = MetricsApi(client)
    now = time.time()
    start = int(now - hours * 3600)
    end = int(now)

    try:
        # List all custom metrics
        metrics_response = api.list_active_metrics(start)
        active_metrics = [m for m in metrics_response.active_metrics if not m.startswith(\"system.\") and not m.startswith(\"process.\")]
        logger.info(f\"Fetched {len(active_metrics)} custom metrics from Datadog\")
        return active_metrics
    except Exception as e:
        logger.error(f\"Failed to fetch Datadog metrics: {e}\")
        return []

def create_otel_metric(metric_name, metric_type=\"counter\"):
    \"\"\"Create an OTel metric matching the Datadog metric type\"\"\"
    if metric_name in otel_metrics:
        return otel_metrics[metric_name]

    if metric_type == \"counter\":
        metric = meter.create_counter(
            name=metric_name,
            description=f\"Migrated from Datadog: {metric_name}\",
            unit=\"1\",
        )
    elif metric_type == \"gauge\":
        metric = meter.create_gauge(
            name=metric_name,
            description=f\"Migrated from Datadog: {metric_name}\",
            unit=\"1\",
        )
    else:
        logger.warning(f\"Unsupported metric type {metric_type} for {metric_name}, defaulting to counter\")
        metric = meter.create_counter(
            name=metric_name,
            description=f\"Migrated from Datadog: {metric_name}\",
            unit=\"1\",
        )

    otel_metrics[metric_name] = metric
    return metric

def migrate_metrics(datadog_metrics):
    \"\"\"Migrate Datadog metrics to OTel (simulated data for example)\"\"\"
    for metric_name in datadog_metrics:
        # In production, you would fetch actual metric values from Datadog API
        # For this example, we simulate a counter metric
        metric = create_otel_metric(metric_name, \"counter\")
        # Simulate adding 100 to the counter
        metric.add(100, attributes={\"migration.status\": \"complete\"})
        logger.info(f\"Migrated metric {metric_name} to OpenTelemetry\")
        time.sleep(0.01)  # Rate limit to avoid overwhelming OTel Collector

def main():
    if not DD_API_KEY or not DD_APP_KEY:
        logger.error(\"DD_API_KEY and DD_APP_KEY must be set\")
        return

    # Initialize Datadog client
    with init_datadog_client() as client:
        # Fetch custom metrics from Datadog
        datadog_metrics = fetch_datadog_metrics(client)
        if not datadog_metrics:
            logger.error(\"No Datadog metrics to migrate\")
            return

        # Migrate metrics to OTel
        migrate_metrics(datadog_metrics)

        # Keep process running to expose /metrics endpoint for Prometheus scraping
        logger.info(\"Migration complete. Exposing /metrics endpoint on :9090\")
        from prometheus_client import start_http_server
        start_http_server(9090)
        while True:
            time.sleep(60)

if __name__ == \"__main__\":
    main()

// prom_benchmark.go
// Benchmarks query latency between Prometheus 2.50 and Datadog 7.0
// Uses Prometheus API and Datadog API to run identical queries
package main

import (
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"log\"
    \"os\"
    \"time\"

    \"github.com/prometheus/client_golang/api\"
    v1 \"github.com/prometheus/client_golang/api/prometheus/v1\"
    \"github.com/prometheus/common/model\"
    datadog \"github.com/DataDog/datadog-api-client-go/v2/api/datadog\"
)

// Benchmark configuration
const (
    prometheusURL = \"http://localhost:9090\"
    datadogSite   = \"datadoghq.com\"
    query         = \"sum(rate(http_requests_total[5m]))\" // Identical query for both
    iterations    = 100
)

func benchmarkPrometheus(ctx context.Context) ([]time.Duration, error) {
    client, err := api.NewClient(api.Config{Address: prometheusURL})
    if err != nil {
        return nil, fmt.Errorf(\"failed to create Prometheus client: %w\", err)
    }

    v1api := v1.NewAPI(client)
    latencies := make([]time.Duration, 0, iterations)

    for i := 0; i < iterations; i++ {
        start := time.Now()
        _, _, err := v1api.Query(ctx, query, time.Now())
        if err != nil {
            return nil, fmt.Errorf(\"prometheus query failed: %w\", err)
        }
        latencies = append(latencies, time.Since(start))
    }

    return latencies, nil
}

func benchmarkDatadog(ctx context.Context) ([]time.Duration, error) {
    // Initialize Datadog client
    cfg := datadog.NewConfiguration()
    cfg.AddDefaultHeader(\"DD-API-KEY\", os.Getenv(\"DD_API_KEY\"))
    cfg.AddDefaultHeader(\"DD-APPLICATION-KEY\", os.Getenv(\"DD_APP_KEY\"))
    cfg.ServerVariables[\"site\"] = datadogSite

    client := datadog.NewAPIClient(cfg)
    latencies := make([]time.Duration, 0, iterations)

    for i := 0; i < iterations; i++ {
        start := time.Now()
        // Datadog query API (equivalent to PromQL sum(rate(http_requests_total[5m])))
        queryBody := datadog.QueryRequest{
            Query: datadog.PtrString(\"sum:trace.http.requests.total{*}.as_rate()\"),
            From:  datadog.PtrInt64(time.Now().Add(-5 * time.Minute).Unix()),
            To:    datadog.PtrInt64(time.Now().Unix()),
        }

        _, _, err := client.MetricsApi.QueryMetrics(ctx).QueryRequest(queryBody).Execute()
        if err != nil {
            return nil, fmt.Errorf(\"datadog query failed: %w\", err)
        }
        latencies = append(latencies, time.Since(start))
    }

    return latencies, nil
}

func calculateP99(latencies []time.Duration) time.Duration {
    // Sort latencies
    sorted := make([]time.Duration, len(latencies))
    copy(sorted, latencies)
    // Simple sort for example (use sort.Slice in production)
    for i := 0; i < len(sorted); i++ {
        for j := i + 1; j < len(sorted); j++ {
            if sorted[j] < sorted[i] {
                sorted[i], sorted[j] = sorted[j], sorted[i]
            }
        }
    }

    p99Index := int(float64(len(sorted)) * 0.99)
    if p99Index >= len(sorted) {
        p99Index = len(sorted) - 1
    }
    return sorted[p99Index]
}

func main() {
    ctx := context.Background()

    // Benchmark Prometheus 2.50
    log.Println(\"Benchmarking Prometheus 2.50...\")
    promLatencies, err := benchmarkPrometheus(ctx)
    if err != nil {
        log.Fatalf(\"Prometheus benchmark failed: %v\", err)
    }
    promP99 := calculateP99(promLatencies)
    log.Printf(\"Prometheus 2.50 p99 query latency: %v\", promP99)

    // Benchmark Datadog 7.0
    log.Println(\"Benchmarking Datadog 7.0...\")
    ddLatencies, err := benchmarkDatadog(ctx)
    if err != nil {
        log.Fatalf(\"Datadog benchmark failed: %v\", err)
    }
    ddP99 := calculateP99(ddLatencies)
    log.Printf(\"Datadog 7.0 p99 query latency: %v\", ddP99)

    // Output results as JSON
    results := map[string]string{
        \"prometheus_p99\": promP99.String(),
        \"datadog_p99\":    ddP99.String(),
        \"improvement\":    fmt.Sprintf(\"%.1f%%\", float64(ddP99-promP99)/float64(ddP99)*100),
    }
    jsonResults, _ := json.MarshalIndent(results, \"\", \"  \")
    fmt.Println(string(jsonResults))
}

processors:
  transform:
    metric_statements:
      - context: metric
        statements:
          - set(name, \"http.requests.total\") where name == \"dd.http.requests.count\"
          - set(name, \"http.request.duration\") where name == \"dd.http.request.duration\"
          - drop() where name startsWith(\"dd.unused.\")

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

groups:
  - name: http_requests_recording_rules
    interval: 30s
    rules:
      - record: http_requests_total:aggregated
        expr: sum(rate(http_requests_total[5m])) by (method, path, status_code)
        labels:
          aggregation: \"dropped_user_id\"