┌─────────────────────────────────────────────────────────────┐
│                    DATADOG PLATFORM                          │
├─────────────────────────────────────────────────────────────┤
│  Metrics │ Traces │ Logs │ Security │ RUM │ Synthetics       │
├─────────────────────────────────────────────────────────────┤
│  Unified Tagging │ Service Catalog │ Watchdog AI              │
├─────────────────────────────────────────────────────────────┤
│  Agent │ Agentless │ APIs │ OpenTelemetry │ Integrations      │
├─────────────────────────────────────────────────────────────┤
│  AWS │ Azure │ GCP │ Kubernetes │ On-Premises │ Serverless    │
└─────────────────────────────────────────────────────────────┘

undefined

**Implementation Steps:**
```bash

**Post-Deployment Verification:**
- Check Service Map for auto-discovered services
- Verify APM traces in Trace Search
- Confirm log ingestion from containers
- Review Security Signals for runtime threats

---

undefined

# OTLP exporter to Datadog Agent
otlp_exporter = OTLPSpanExporter(
    endpoint="http://localhost:4317",
    insecure=True
)

span_processor = BatchSpanProcessor(otlp_exporter)
provider.add_span_processor(span_processor)
trace.set_tracer_provider(provider)

# Instrument Flask and requests
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()

    # Database call with child span
    with tracer.start_as_current_span("db.query") as db_span:
        db_span.set_attribute("db.system", "postgresql")
        order_data = query_database(order_id)
    
    # External service call
    with tracer.start_as_current_span("inventory.check") as inv_span:
        inv_span.set_attribute("peer.service", "inventory-service")
        inventory = requests.get(
            f"http://inventory-service:8080/stock/{order_id}"
        )
    
    # Custom metric
    statsd.increment("order.api.requests", 
        tags=["endpoint:get_order"])
    
    return order_data

**Key Datadog Features Enabled:**
- Flame graph visualization of request traces
- Service dependency mapping
- Automatic error tracking and analytics
- Correlation with logs and infrastructure metrics
- Custom business metrics aggregation

---

undefined

group_by_fields = ["@userIdentity.userName", "@sourceIPAddress"]

**Security Dashboard:**
```json
{
  "title": "Cloud Security Overview",
  "widgets": [
    {
      "definition": {
        "title": "CSPM Compliance Score",
        "type": "query_value",
        "requests": [{
          "formulas": [{"formula": "compliant / total * 100"}],
          "queries": [
            {"data_source": "security_findings", 
             "query": "source:cspm status:pass", 
             "name": "compliant", "aggregator": "count"},
            {"data_source": "security_findings", 
             "query": "source:cspm", 
             "name": "total", "aggregator": "count"}
          ]
        }],
        "autoscale": false,
        "precision": 1,
        "unit": "%"
      }
    },
    {
      "definition": {
        "title": "Security Signals by Severity",
        "type": "toplist",
        "requests": [{
          "queries": [{
            "data_source": "security_signals", 
            "query": "status:high OR status:critical", 
            "name": "count", "aggregator": "count"
          }]
        }]
      }
    }
  ],
  "tags": ["team:security", "env:production"]
}

undefined

**Error Budget Alert Configuration:**
```hcl

@pagerduty-payments-oncall
{{/is_alert}}

{{#is_warning}}
Error budget consumption elevated for Payment API.
Review recent deployments and performance trends.
@slack-payments-alerts
{{/is_warning}}

**Error Budget Policy Document:**
```markdown

---

// datadog-rum.ts - RUM initialization module
import { datadogRum } from '@datadog/browser-rum';
import { datadogLogs } from '@datadog/browser-logs';

interface RUMConfig {
  env: 'production' | 'staging' | 'development';
  version: string;
  service: string;
  allowedTracingOrigins: string[];
}

export function initDatadogRUM(config: RUMConfig): void {
  // Initialize RUM
  datadogRum.init({
    applicationId: process.env.REACT_APP_DD_RUM_APP_ID!,
    clientToken: process.env.REACT_APP_DD_RUM_CLIENT_TOKEN!,
    site: 'datadoghq.com',
    service: config.service,
    env: config.env,
    version: config.version,
    
    // Session configuration
    sessionSampleRate: config.env === 'production' ? 100 : 100,
    sessionReplaySampleRate: config.env === 'production' ? 20 : 100,
    
    // Privacy settings
    defaultPrivacyLevel: 'mask-user-input',
    
    // Tracking options
    trackUserInteractions: true,
    trackResources: true,
    trackLongTasks: true,
    
    // APM integration - connect frontend to backend traces
    allowedTracingUrls: config.allowedTracingOrigins.map(origin => ({
      match: origin,
      propagatorTypes: ['datadog', 'tracecontext'],
    })),
  });

  // Initialize Logs
  datadogLogs.init({
    clientToken: process.env.REACT_APP_DD_RUM_CLIENT_TOKEN!,
    site: 'datadoghq.com',
    service: config.service,
    env: config.env,
    version: config.version,
    forwardErrorsToLogs: true,
    sessionSampleRate: 100,
  });

  // Set global context for all events
  datadogRum.setRumGlobalContext({
    app_type: 'spa',
    framework: 'react',
  });
}

// User identification (call after login)
export function identifyUser(userId: string, 
    attributes: Record<string, any>): void {
  datadogRum.setUser({
    id: userId,
    ...attributes,
  });
}

// Custom action tracking
export function trackCustomAction(actionName: string, 
    context?: Record<string, any>): void {
  datadogRum.addAction(actionName, context);
}

// Error tracking
export function trackError(error: Error, 
    context?: Record<string, any>): void {
  datadogRum.addError(error, context);
  datadogLogs.error(error.message, { 
    error: error.stack, ...context 
  });
}

{
  "config": {
    "assertions": [
      {
        "operator": "is",
        "type": "statusCode",
        "target": 200
      },
      {
        "operator": "lessThan",
        "type": "responseTime",
        "target": 1000
      },
      {
        "operator": "validatesJSONPath",
        "type": "body",
        "target": {
          "jsonPath": "$.status",
          "operator": "is",
          "expectedValue": "healthy"
        }
      }
    ],
    "request": {
      "method": "GET",
      "url": "https://api.example.com/health",
      "headers": {
        "Accept": "application/json"
      }
    }
  },
  "locations": [
    "aws:us-east-1",
    "aws:eu-west-1",
    "aws:ap-southeast-1"
  ],
  "message": "API health check failed @pagerduty-oncall",
  "name": "API Health Check - Multi-Region",
  "options": {
    "min_failure_duration": 300,
    "min_location_failed": 2,
    "tick_every": 60
  },
  "subtype": "http",
  "type": "api",
  "tags": ["service:api", "check-type:health", "env:production"]
}