Claude Code Research

Claude Code Integration with Modern Observability Platforms

5 min read

Claude Code Integration with Modern Observability Platforms

Overview

Claude Code supports OpenTelemetry (OTel) integration, enabling you to stream token usage, session metrics, and command data to any backend that speaks the OpenTelemetry Protocol (OTLP). This guide covers integration patterns with major observability platforms for production Claude Code deployments.

OpenTelemetry Foundation

Claude Code exports two types of telemetry data:

  • Metrics: Time series data for token usage, API latency, and resource consumption
  • Events/Logs: Detailed interaction logs including tool usage and session events

Basic Configuration

# Enable telemetry export
export CLAUDE_CODE_ENABLE_TELEMETRY=1
 
# Configure exporters
export OTEL_METRICS_EXPORTER=otlp  # Options: otlp, prometheus, console
export OTEL_LOGS_EXPORTER=otlp     # Options: otlp, console
 
# Configure OTLP endpoint
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
 
# Production intervals (default: 60s metrics, 5s logs)
export OTEL_METRIC_EXPORT_INTERVAL=60000
export OTEL_LOG_EXPORT_INTERVAL=5000

Datadog Integration

Datadog offers three integration approaches for Claude Code metrics:

1. OTLP Intake Endpoint (Preview)

# datadog-otel-config.yaml
exporters:
  otlphttp:
    endpoint: https://otel.datadoghq.com:443
    headers:
      DD-API-KEY: ${DD_API_KEY}

2. Datadog Agent with OTLP Support

# datadog-agent.yaml
otlp_config:
  receiver:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

3. Claude Code Datadog Exporter

import { DatadogMetrics } from '@datadog/datadog-api-client';
import { ClaudeCodeTelemetry } from '@anthropic-ai/claude-code';
 
const telemetry = new ClaudeCodeTelemetry({
  exporter: new DatadogOTLPExporter({
    apiKey: process.env.DD_API_KEY,
    site: 'datadoghq.com',
    service: 'claude-code-production',
    env: 'production'
  })
});

Datadog Dashboard Configuration

Create custom dashboards to track:

  • Token usage by model and user
  • API request latency percentiles
  • Tool execution frequency
  • Error rates and retry patterns

Grafana Cloud Integration

Grafana Cloud provides native OpenTelemetry support through Grafana Alloy:

1. Configure Grafana Alloy

otelcol.receiver.otlp "claude_code" {
  grpc {
    endpoint = "0.0.0.0:4317"
  }
  
  http {
    endpoint = "0.0.0.0:4318"
  }
}
 
otelcol.exporter.prometheus "grafana_cloud" {
  forward_to = [prometheus.remote_write.grafana_cloud.receiver]
}
 
prometheus.remote_write "grafana_cloud" {
  endpoint {
    url = "https://prometheus-prod-10-prod-us-central-0.grafana.net/api/prom/push"
    basic_auth {
      username = "${GRAFANA_CLOUD_INSTANCE_ID}"
      password = "${GRAFANA_CLOUD_API_KEY}"
    }
  }
}

2. AI Observability Features

Grafana’s AI Observability solution provides:

  • LLM-specific metrics visualization
  • Token usage cost analysis
  • Prompt/response latency tracking
  • Model performance comparison

New Relic Integration

New Relic deeply supports OpenTelemetry with native ingestion:

1. Direct OTLP Export

// claude-code-config.ts
export const observabilityConfig = {
  endpoint: 'otlp.nr-data.net:4317',
  headers: {
    'api-key': process.env.NEW_RELIC_LICENSE_KEY
  },
  serviceName: 'claude-code-production',
  attributes: {
    'ai.model': 'claude-4-opus',
    'deployment.environment': 'production'
  }
};

2. New Relic AI Monitoring

Leverage New Relic’s AI monitoring capabilities:

  • AI transaction tracing
  • Token economics dashboard
  • Anomaly detection for usage patterns
  • Cost optimization recommendations

Production Monitoring Stack

1. Multi-Platform Strategy

// observability-config.ts
import { CompositeTelemetryExporter } from './telemetry';
 
const exporter = new CompositeTelemetryExporter([
  // Primary: Datadog for APM
  new DatadogExporter({ /* config */ }),
  
  // Secondary: Grafana for visualization
  new GrafanaExporter({ /* config */ }),
  
  // Backup: S3 for long-term storage
  new S3ArchiveExporter({ /* config */ })
]);

2. Key Metrics to Monitor

Token Usage Metrics

const tokenMetrics = {
  'claude.tokens.input': inputTokens,
  'claude.tokens.output': outputTokens,
  'claude.tokens.cached': cachedTokens,
  'claude.tokens.cost_usd': calculateCost(tokens)
};

Performance Metrics

const performanceMetrics = {
  'claude.api.latency': apiLatency,
  'claude.api.requests': requestCount,
  'claude.tool.execution_time': toolExecutionTime,
  'claude.session.duration': sessionDuration
};

Business Metrics

const businessMetrics = {
  'claude.users.active': activeUsers,
  'claude.sessions.completed': completedSessions,
  'claude.tasks.success_rate': successRate,
  'claude.cost.per_user': costPerUser
};

Advanced Patterns

1. Distributed Tracing

import { trace } from '@opentelemetry/api';
 
const tracer = trace.getTracer('claude-code-app');
 
async function executeClaudeTask(prompt: string) {
  const span = tracer.startSpan('claude.task.execute');
  
  try {
    span.setAttributes({
      'claude.prompt.length': prompt.length,
      'claude.model': 'opus-4'
    });
    
    const result = await claudeCode({ prompt });
    
    span.setAttributes({
      'claude.tokens.total': result.usage.totalTokens,
      'claude.tools.used': result.toolsUsed.join(',')
    });
    
    return result;
  } finally {
    span.end();
  }
}

2. Custom Dashboards

Datadog Dashboard JSON

{
  "title": "Claude Code Production Monitoring",
  "widgets": [
    {
      "definition": {
        "type": "timeseries",
        "requests": [{
          "q": "avg:claude.tokens.cost_usd{env:production} by {model}",
          "display_type": "line"
        }]
      }
    },
    {
      "definition": {
        "type": "heatmap",
        "requests": [{
          "q": "avg:claude.api.latency{env:production} by {endpoint}"
        }]
      }
    }
  ]
}

3. Alerting Configuration

# alerts.yaml
alerts:
  - name: high_token_usage
    query: sum(rate(claude_tokens_total[5m])) > 10000
    severity: warning
    
  - name: api_latency_spike
    query: histogram_quantile(0.95, claude_api_latency_bucket) > 5
    severity: critical
    
  - name: cost_threshold_exceeded
    query: sum(claude_tokens_cost_usd) > 1000
    severity: critical

Best Practices

1. Resource Tagging

const standardTags = {
  environment: process.env.NODE_ENV,
  service: 'claude-code',
  version: process.env.APP_VERSION,
  team: 'ai-platform',
  cost_center: 'engineering'
};

2. Sampling Strategy

// Implement intelligent sampling for high-volume deployments
const samplingConfig = {
  // Sample 100% of errors
  errorSampling: 1.0,
  
  // Sample 10% of successful requests
  successSampling: 0.1,
  
  // Sample 100% of high-cost operations
  costThresholdSampling: {
    threshold: 1.0, // USD
    rate: 1.0
  }
};

3. Data Retention

  • Hot storage: 7 days in Datadog/New Relic
  • Warm storage: 30 days in Grafana
  • Cold storage: 1 year in S3/GCS

Troubleshooting

Common Issues

  1. No telemetry data exported

    • Verify CLAUDE_CODE_ENABLE_TELEMETRY=1
    • Check network connectivity to OTLP endpoint
    • Validate authentication credentials

  2. Missing metrics in dashboard

    • Ensure correct metric names and tags
    • Check retention policies
    • Verify exporter configuration

  3. High cardinality warnings

    • Limit unique tag values
    • Use sampling for high-volume metrics
    • Aggregate before export

Security Considerations

  1. Credential Management

    # Use environment variables or secret management
export DD_API_KEY=$(vault read -field=api_key secret/datadog)
export NEW_RELIC_LICENSE_KEY=$(aws secretsmanager get-secret-value --secret-id nr-license)

  2. Data Privacy

    • Never log prompts or responses
    • Hash user identifiers
    • Implement data retention policies

  3. Network Security

    • Use TLS for all telemetry exports
    • Implement IP allowlisting
    • Use private endpoints where available

Conclusion

Integrating Claude Code with modern observability platforms enables comprehensive monitoring of AI workloads in production. By leveraging OpenTelemetry as the standard, teams can build flexible, vendor-agnostic monitoring solutions that scale with their needs.

Last verified: 2025-07-21
Source: Web research and OpenTelemetry documentation

Graph View

Backlinks