Anthropic Integration

import * as Sentry from '@sentry/node';

Sentry.init({
  dsn: 'your-dsn',
  // anthropicAIIntegration is included by default
});

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// Automatically instrumented
const message = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'What is the capital of France?' },
  ],
});

Sentry.init({
  dsn: 'your-dsn',
  sendDefaultPii: false, // Default: no prompts/responses
});

{
  'gen_ai.operation.name': 'chat',
  'gen_ai.request.model': 'claude-3-5-sonnet-20241022',
  'gen_ai.system': 'anthropic',
  'gen_ai.usage.input_tokens': 20,
  'gen_ai.usage.output_tokens': 95,
  'gen_ai.response.finish_reasons': ['end_turn'],
  'gen_ai.request.temperature': 1.0,
  'gen_ai.request.max_tokens': 1024,
}

{
  'gen_ai.system': 'You are a helpful AI assistant.',
  'gen_ai.prompt.0.role': 'user',
  'gen_ai.prompt.0.content': 'What is the capital of France?',
}

{
  'gen_ai.completion.0.role': 'assistant',
  'gen_ai.completion.0.content': 'The capital of France is Paris.',
  'gen_ai.completion.0.finish_reason': 'end_turn',
}

const message = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Hello, Claude!' },
  ],
});
// Span: gen_ai.chat.completions

const stream = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Tell me a story' }],
  stream: true,
});

for await (const event of stream) {
  if (event.type === 'content_block_delta') {
    process.stdout.write(event.delta.text);
  }
}
// Span includes full streaming response

const message = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  system: 'You are a helpful customer service agent.',
  messages: [
    { role: 'user', content: 'I need help with my order' },
  ],
});
// System prompt captured when recordInputs: true

const message = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  tools: [
    {
      name: 'get_weather',
      description: 'Get the current weather for a location',
      input_schema: {
        type: 'object',
        properties: {
          location: {
            type: 'string',
            description: 'City name',
          },
        },
        required: ['location'],
      },
    },
  ],
  messages: [
    { role: 'user', content: 'What is the weather in Paris?' },
  ],
});
// Tool use captured in span attributes

import * as Sentry from '@sentry/node';
import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

async function chat(conversationHistory) {
  return await Sentry.startSpan(
    {
      name: 'Claude Chat',
      op: 'ai.chat',
      attributes: {
        'conversation.turns': conversationHistory.length,
      },
    },
    async () => {
      const message = await anthropic.messages.create({
        model: 'claude-3-5-sonnet-20241022',
        max_tokens: 1024,
        messages: conversationHistory,
      });
      
      return message.content[0].text;
    }
  );
}

// Usage
const history = [
  { role: 'user', content: 'What is 2+2?' },
  { role: 'assistant', content: '2+2 equals 4.' },
  { role: 'user', content: 'What about 3+3?' },
];

const response = await chat(history);

async function moderateContent(content) {
  return await Sentry.startSpan(
    {
      name: 'Content Moderation',
      op: 'ai.moderation',
    },
    async () => {
      const message = await anthropic.messages.create({
        model: 'claude-3-5-sonnet-20241022',
        max_tokens: 256,
        system: 'You are a content moderation assistant. Analyze the following content and determine if it violates community guidelines.',
        messages: [
          { role: 'user', content },
        ],
      });
      
      return {
        safe: message.content[0].text.includes('safe'),
        analysis: message.content[0].text,
      };
    }
  );
}

async function analyzeDocument(documentText) {
  return await Sentry.startSpan(
    {
      name: 'Analyze Document',
      op: 'ai.analysis',
      attributes: {
        'document.length': documentText.length,
      },
    },
    async () => {
      const message = await anthropic.messages.create({
        model: 'claude-3-5-sonnet-20241022',
        max_tokens: 2048,
        messages: [
          {
            role: 'user',
            content: `Please analyze this document and provide a summary:\n\n${documentText}`,
          },
        ],
      });
      
      return message.content[0].text;
    }
  );
}

async function getWeatherAssistant(userQuery) {
  const tools = [
    {
      name: 'get_weather',
      description: 'Get current weather for a location',
      input_schema: {
        type: 'object',
        properties: {
          location: { type: 'string' },
          unit: { type: 'string', enum: ['celsius', 'fahrenheit'] },
        },
        required: ['location'],
      },
    },
  ];

  return await Sentry.startSpan(
    { name: 'Weather Assistant', op: 'ai.tool_use' },
    async () => {
      const message = await anthropic.messages.create({
        model: 'claude-3-5-sonnet-20241022',
        max_tokens: 1024,
        tools,
        messages: [{ role: 'user', content: userQuery }],
      });

      // Check if Claude wants to use a tool
      const toolUse = message.content.find(block => block.type === 'tool_use');
      
      if (toolUse) {
        // Call the actual weather API
        const weatherData = await fetchWeather(toolUse.input.location);
        
        // Continue conversation with tool result
        const followUp = await anthropic.messages.create({
          model: 'claude-3-5-sonnet-20241022',
          max_tokens: 1024,
          tools,
          messages: [
            { role: 'user', content: userQuery },
            { role: 'assistant', content: message.content },
            {
              role: 'user',
              content: [
                {
                  type: 'tool_result',
                  tool_use_id: toolUse.id,
                  content: JSON.stringify(weatherData),
                },
              ],
            },
          ],
        });
        
        return followUp.content[0].text;
      }
      
      return message.content[0].text;
    }
  );
}

Sentry.init({
  dsn: 'your-dsn',
  sendDefaultPii: true,
  
  beforeSendSpan(span) {
    // Remove PII from prompts
    const promptContent = span.attributes?.['gen_ai.prompt.0.content'];
    if (promptContent && typeof promptContent === 'string') {
      // Redact email addresses
      span.attributes['gen_ai.prompt.0.content'] = promptContent
        .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL]');
    }
    
    return span;
  },
});

async function processQuery(query, options = {}) {
  const isPublic = options.isPublic ?? false;
  
  // Use a custom client configuration based on sensitivity
  const integrations = isPublic
    ? [Sentry.anthropicAIIntegration({ recordInputs: true, recordOutputs: true })]
    : [Sentry.anthropicAIIntegration({ recordInputs: false, recordOutputs: false })];
  
  // Process with appropriate privacy settings
  const message = await anthropic.messages.create({...});
  return message;
}

Sentry.init({
  dsn: 'your-dsn',
  tracesSampleRate: 1.0, // Capture 100% of traces
});

Sentry.anthropicAIIntegration({
  recordOutputs: true, // Captures tool use blocks
});