Zero-Code AI Agent Monitoring with OpenTelemetry

npm init -y
npm install @getfoil/foil-js openai
# @opentelemetry/api is included as a dependency — no extra install

const { Foil } = require('@getfoil/foil-js/otel');

Foil.init({
  apiKey: process.env.FOIL_API_KEY,
  agentName: 'my-agent',
});

// Import LLM clients AFTER Foil.init() — this is required
// so auto-instrumentation hooks are active when modules load
const OpenAI = require('openai');

// That's it. Every OpenAI/Anthropic call is now auto-traced.

const { Foil } = require('@getfoil/foil-js/otel');
// @opentelemetry/api is already installed — it's a dependency of @getfoil/foil-js
const { trace } = require('@opentelemetry/api');

// Initialize Foil BEFORE importing LLM clients
Foil.init({
  apiKey: process.env.FOIL_API_KEY,
  agentName: 'customer-support',
});

// Import OpenAI AFTER Foil.init() so auto-instrumentation hooks are active
const OpenAI = require('openai');

const openai = new OpenAI();
const tracer = trace.getTracer('customer-support');

// Tool definition for looking up order status
const tools = [
  {
    type: 'function',
    function: {
      name: 'lookup_order',
      description: 'Look up the status of an order by order ID',
      parameters: {
        type: 'object',
        properties: {
          order_id: { type: 'string', description: 'The order ID, e.g. ORD-12345' },
        },
        required: ['order_id'],
      },
    },
  },
];

// Mock implementation — replace with your real order lookup
function lookupOrder(orderId) {
  return { order_id: orderId, status: 'shipped', eta: '2025-02-15' };
}

async function handleQuery(question) {
  // Manual parent span — auto-traced OpenAI calls nest inside it
  return tracer.startActiveSpan('handle-query', async (span) => {
    try {
      const messages = [
        { role: 'system', content: 'You are a helpful support agent for TechMart.' },
        { role: 'user', content: question },
      ];

      // First LLM call — may return tool_calls (auto-traced)
      const first = await openai.chat.completions.create({
        model: 'gpt-4o-mini',
        messages,
        tools,
      });

      const choice = first.choices[0];

      if (choice.finish_reason === 'tool_calls') {
        messages.push(choice.message);

        for (const tc of choice.message.tool_calls) {
          const args = JSON.parse(tc.function.arguments);
          const result = lookupOrder(args.order_id);
          messages.push({
            role: 'tool',
            tool_call_id: tc.id,
            content: JSON.stringify(result),
          });
        }

        // Second LLM call — generates final answer (auto-traced)
        const second = await openai.chat.completions.create({
          model: 'gpt-4o-mini',
          messages,
        });

        return second.choices[0].message.content;
      }

      return choice.message.content;
    } finally {
      span.end();
    }
  });
}

(async () => {
  const answer = await handleQuery('Can you check on order ORD-12345?');
  console.log(`Q: Can you check on order ORD-12345?`);
  console.log(`A: ${answer}\n`);

  console.log('Flushing traces to Foil...');
  await Foil.flush();
  console.log('Done! View your traces at https://app.getfoil.ai\n');
})();

FOIL_API_KEY=sk_live_xxx OPENAI_API_KEY=sk-xxx node customer_support.js

const { Foil } = require('@getfoil/foil-js/otel');

Foil.init({
  apiKey: process.env.FOIL_API_KEY,
  agentName: 'rag-pipeline',
});

// Import OpenAI AFTER Foil.init()
const OpenAI = require('openai');
const openai = new OpenAI();

async function ragQuery(userQuestion) {
  // Step 1: Embed the query — auto-traced
  const embedding = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: userQuestion,
  });

  // Step 2: Retrieve docs — your code, NOT auto-traced
  const docs = await vectorStore.search(embedding.data[0].embedding, { topK: 3 });

  // Step 3: Generate answer — auto-traced
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: `Answer based on the following context:\n${docs.map(d => d.content).join('\n')}`,
      },
      { role: 'user', content: userQuestion },
    ],
  });

  return response.choices[0].message.content;
}

(async () => {
  const answer = await ragQuery('How do I reset my password?');
  console.log(answer);

  await Foil.flush();
})();

const { Foil } = require('@getfoil/foil-js');

const foil = new Foil({ apiKey: process.env.FOIL_API_KEY });

// Create a custom evaluation — runs on every trace automatically
await foil.createEvaluation(agentId, {
  name: 'groundedness_check',
  description: 'Checks if the response is grounded in retrieved documents',
  prompt: `Evaluate whether the assistant response is grounded in the provided context.
Return true if grounded, false if it contains hallucinated or unsupported claims.

Input: {input}
Output: {output}`,
  evaluationType: 'boolean',
  enabled: true,
});

// Clone a pre-built template
await foil.cloneEvaluationTemplate(agentId, 'data_leakage');

// Flush any pending spans (e.g., before responding to a request)
await Foil.flush();

// Shutdown when your app exits (flushes + closes connections)
await Foil.shutdown();