Automatic instrumentation

We always recommend using the instrumentModules parameter to specify which modules to instrument. Automatic instrumentation of imported modules may work, but it depends on many factors, such as the bundler you are using.

Instrument all available libraries

This method is not recommended in JavaScript. It may not work for all setups. Please read the section on specific modules instrumentation.

import { Laminar } from '@lmnr-ai/lmnr';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY
});

// and then import the instrumentable modules
// ...
import { OpenAI } from 'openai';
import * as anthropic from '@anthropic-ai/sdk';

This method is not recommended in JavaScript. It may not work for all setups. Please read the section on specific modules instrumentation.

import { Laminar } from '@lmnr-ai/lmnr';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY
});

// and then import the instrumentable modules
// ...
import { OpenAI } from 'openai';
import * as anthropic from '@anthropic-ai/sdk';

from lmnr import Laminar
import os
from openai import OpenAI
# ...
Laminar.initialize(project_api_key=os.environ["LMNR_PROJECT_API_KEY"])

See all available auto-instrumentable modules here.

Disable automatic instrumentation

initialize() accepts an optional instrumentModules parameter. If you explicitly pass an empty object, no automatic instrumentations will be applied.

import { Laminar } from '@lmnr-ai/lmnr';
import { OpenAI } from 'openai';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY,
  instrumentModules: {}
});

// When you call OpenAI, it will NOT be instrumented

initialize() accepts an optional instrumentModules parameter. If you explicitly pass an empty object, no automatic instrumentations will be applied.

import { Laminar } from '@lmnr-ai/lmnr';
import { OpenAI } from 'openai';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY,
  instrumentModules: {}
});

// When you call OpenAI, it will NOT be instrumented

initialize() accepts an optional instruments parameter. If you explicitly pass an empty set, no automatic instrumentations will be applied.

from lmnr import Laminar
import os
from openai import OpenAI

Laminar.initialize(
    project_api_key=os.environ["LMNR_PROJECT_API_KEY"],
    instruments=set()
)

# When you call OpenAI, it will NOT be instrumented

Instrument specific modules only

You can also enable instrumentation for specific modules only.

This is useful if you want more control over what is being instrumented.

For many JavaScript setups, this may be required. For example, in TS, we’ve seen this required for tsx, but not for ts-node.

Show technical details on JavaScript automatic instrumentation

Automatic instrumentation is done by patching the import/require statements.

In many setups, if a module, e.g. openai is imported after Laminar (and so, the underlying OpenTelemetry Tracer) is initialized, the instrumentation will not be applied.

Most bundlers will allow an import after initialization, but some bundlers, will first evaluate the import statements, and so, even moving the import after initialization will not work.

In such setups, it is recommended to manually instrument the modules you need.

When you pass the entire module to instrumentModules, our tracer will have access to the exports of the module, despite the fact that it’s already imported.

Let’s say, for example, we call OpenAI and Anthropic models to perform the same task, and we only want to instrument the Anthropic calls, but not OpenAI.

initialize() accepts an optional instrumentModules parameter. It takes in an object with string keys and values are the entire modules you have imported. In this case we only want to pass anthropic.

If you are using AI SDK and/or Next.js, you may need additional configuration. Please refer to the Next.js guide for more details.

See available instruments in the next subsection.

import { OpenAI } from 'openai';
import * as anthropic from '@anthropic-ai/sdk';
import { Laminar } from '@lmnr-ai/lmnr';

Laminar.initialize(
  { projectApiKey: process.env.LMNR_PROJECT_API_KEY,
    instrumentModules: {
      anthropic: anthropic // only enable anthropic, not openai
    }
  }
);

const openAIClient = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const anthropicClient = new anthropic.Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
});

const poemWriter = async (topic = "turbulence") => {
  const prompt = `write a poem about ${topic}`;
  const messages = [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: prompt }
  ];

  // openai calls are NOT instrumented
  const openAIResponse = await openAIClient.chat.completions.create({
    model: "gpt-4o",
    messages,
  });
  
  // anthropic calls are instrumented
  const anthropicResponse = await anthropicClient.messages.create({
    max_tokens: 1024,
    messages,
    model: "claude-3-5-sonnet-20240620",
  })

  const openAIPoem = response.choices[0].message.content;
  const anthropicPoem = anthropicResponse.content[0].text;
  return {o: openAIPoem, a: anthropicPoem};
}

If you are using AI SDK and/or Next.js, you may need additional configuration. Please refer to the Next.js guide for more details.

See available instruments in the next subsection.

import { OpenAI } from 'openai';
import * as anthropic from '@anthropic-ai/sdk';
import { Laminar } from '@lmnr-ai/lmnr';

Laminar.initialize(
  { projectApiKey: process.env.LMNR_PROJECT_API_KEY,
    instrumentModules: {
      anthropic: anthropic // only enable anthropic, not openai
    }
  }
);

const openAIClient = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const anthropicClient = new anthropic.Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
});

const poemWriter = async (topic = "turbulence") => {
  const prompt = `write a poem about ${topic}`;
  const messages = [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: prompt }
  ];

  // openai calls are NOT instrumented
  const openAIResponse = await openAIClient.chat.completions.create({
    model: "gpt-4o",
    messages,
  });
  
  // anthropic calls are instrumented
  const anthropicResponse = await anthropicClient.messages.create({
    max_tokens: 1024,
    messages,
    model: "claude-3-5-sonnet-20240620",
  })

  const openAIPoem = response.choices[0].message.content;
  const anthropicPoem = anthropicResponse.content[0].text;
  return {o: openAIPoem, a: anthropicPoem};
}

initialize() accepts an optional instruments parameter. Pass a set of instruments you want to enable. In this case we only want to pass Instruments.ANTHROPIC.

See available instruments in the next subsection.

import os
from anthropic import Anthropic
from openai import OpenAI

from lmnr import Laminar, Instruments

Laminar.initialize(
    project_api_key=os.environ["LMNR_PROJECT_API_KEY"],
    instruments={ Instruments.ANTHROPIC }  # only enable anthropic, not openai
)

openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
anthropic_client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

def poem_writer(topic="turbulence"):
    prompt = f"write a poem about {topic}"
    messages = [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": prompt},
    ]

    # OpenAI calls are NOT instrumented
    openai_response = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
    )

    # Anthropic calls are instrumented
    anthropic_response = anthropic_client.messages.create(
        max_tokens=1024,
        messages=messages,
        model="claude-3-5-sonnet-20240620",
    )

    openai_poem = openai_response.choices[0].message.content
    anthropic_poem = anthropic_response.content[0].text

    return {"o": openai_poem, "a": anthropic_poem}

if __name__ == "__main__":
    print(poem_writer(topic="laminar flow"))

Available instruments

Show full list of modules that you can instrument in JS

openAI
anthropic
azureOpenAI
cohere
bedrock
google_vertexai
google_aiplatform
pinecone
langchain:
- chainsModule
- agentsModule
- toolsModule
- runnablesModule
- vectorStoreModule
llamaIndex
chromadb
qdrant
playwright
puppeteer / puppeteer-core

On this page

Instrument all available libraries
Disable automatic instrumentation
Instrument specific modules only
Available instruments

Instrument all available libraries

This method is not recommended in JavaScript. It may not work for all setups. Please read the section on specific modules instrumentation.

import { Laminar } from '@lmnr-ai/lmnr';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY
});

// and then import the instrumentable modules
// ...
import { OpenAI } from 'openai';
import * as anthropic from '@anthropic-ai/sdk';

This method is not recommended in JavaScript. It may not work for all setups. Please read the section on specific modules instrumentation.

import { Laminar } from '@lmnr-ai/lmnr';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY
});

// and then import the instrumentable modules
// ...
import { OpenAI } from 'openai';
import * as anthropic from '@anthropic-ai/sdk';

from lmnr import Laminar
import os
from openai import OpenAI
# ...
Laminar.initialize(project_api_key=os.environ["LMNR_PROJECT_API_KEY"])

See all available auto-instrumentable modules here.

Disable automatic instrumentation

initialize() accepts an optional instrumentModules parameter. If you explicitly pass an empty object, no automatic instrumentations will be applied.

import { Laminar } from '@lmnr-ai/lmnr';
import { OpenAI } from 'openai';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY,
  instrumentModules: {}
});

// When you call OpenAI, it will NOT be instrumented

initialize() accepts an optional instrumentModules parameter. If you explicitly pass an empty object, no automatic instrumentations will be applied.

import { Laminar } from '@lmnr-ai/lmnr';
import { OpenAI } from 'openai';

Laminar.initialize({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY,
  instrumentModules: {}
});

// When you call OpenAI, it will NOT be instrumented

initialize() accepts an optional instruments parameter. If you explicitly pass an empty set, no automatic instrumentations will be applied.

from lmnr import Laminar
import os
from openai import OpenAI

Laminar.initialize(
    project_api_key=os.environ["LMNR_PROJECT_API_KEY"],
    instruments=set()
)

# When you call OpenAI, it will NOT be instrumented