Learn how to instrument CrewAI applications with OpenTelemetry and export large language model (LLM) telemetry via OTLP into Cribl Search. Once your data is in Cribl Search, you can explore and investigate it to troubleshoot issues, analyze model behavior, and monitor performance.

You’ll complete the following high-level steps:

1. Configure an OpenTelemetry (OTel) Source in Cribl Search to receive OTLP data.
2. Instrument your CrewAI application (Python) with OpenTelemetry.
3. Explore LLM telemetry use cases in Cribl Search.

Telemetry Captured ​

CrewAI runs produce trace spans with these attributes:

Semantic conventions follow OpenTelemetry GenAI Semantic Conventions and OpenInference where applicable.

Prerequisites ​

You’ll need:

• Cribl.Cloud Enterprise.
• Search Admin permission or higher.
• An OpenAI API key or other provider credentials with access to the models you want to monitor (examples below use OpenAI and OPENAI_API_KEY).
• Python 3.10 through 3.13 (current crewai and OpenInference packages do not support Python 3.14).
• CrewAI 1.10.1 or later (current PyPI release is 1.15.x).

Get Data Into Cribl Search ​

Complete these steps before you instrument your LLM application:

1. Add a lakehouse engine. This provides storage and compute for data you’re going to ingest into Cribl Search.
2. Add a Cribl Search OpenTelemetry Source to start ingesting the data.
3. Set up your Datatype rules to parse and structure the incoming data.
4. Set up your Dataset rules to route ingested events into individual Search Datasets. This will let you scope your queries and control retention.

Add a Lakehouse Engine ​

A lakehouse engine is the storage-and-compute unit in Cribl Search that holds ingested OTLP (and other Source data) until Dataset retention expires. See Lakehouse Engines in Cribl Search to learn how to set up a new lakehouse engine.

Configure the OpenTelemetry (OTel) Source in Cribl Search ​

To receive OTLP from your LLM application directly in Cribl Search, add an OpenTelemetry Source.

1. On the Cribl.Cloud top bar, select Products > Search. Under Data, select Add Source > OpenTelemetry.

2. In the New Source modal, configure the following under General Settings:

   • ID: Unique Source ID across your Cribl.Cloud Workspace. Use letters, numbers, underscores, and hyphens.
   • Description (optional): Describe the Source (for example, OTLP from LLM-instrumented apps).
   • Address: Hostname that your OpenTelemetry collector or agent connects to. You will use this in exporter configuration.
   • Port: Network port to listen on. Defaults to 4317 for gRPC and 4318 for HTTP (OTLP standard). Change if you use a custom port.
   • OTLP version: Version that matches your upstream sender (default 1.3.1).
   • Protocol: gRPC (default) or HTTP. This must match your OpenTelemetry exporter.

3. Under Authentication, choose None, Basic, Basic (Credentials Secret), Auth Tokens, or Auth Token (Text Secret) as required. See Set up Authentication.

4. Under Encrypt, enable TLS and set the minimum TLS version when senders must connect over TLS. See Set Up Encryption.

5. Select Save to create the Source.

Set Datatype Rules ​

Next, configure Datatype rules to parse, filter, and normalize your data into structured fields.

On the Cribl.Cloud top bar, select Products > Search > Data > Datatyping (auto). Here, you can:

• Use Auto-Datatyping to parse your data automatically.
• Check for uncategorized data that didn’t match any Datatype rules.
• Handle the uncategorized data by adding custom Datatype rules.

See also:

• Datatypes in Cribl Search
• v2 Datatypes in Cribl Search
• List of Stock v2 Datatypes
• Add a Custom v2 Datatype

Add a Dataset and Set Dataset Rules ​

Next, create a Dataset and add Dataset rules to route parsed events into it.

Add a Dataset ​

1. On the Cribl.Cloud top bar, select Products > Search > Data > Datasets.
2. Select Add Dataset.
3. Enter a unique ID.
4. Optionally add a Description and Tags.
5. Set the Dataset type to Search Dataset.
6. Set the Retention period.
7. Select the Engine that will store the data.
8. Select Save.

Set Dataset Rules ​

Dataset rules enable you to route ingested events into individual Search Datasets so you can scope your queries and control retention.

See Organize Your Data for details around how to configure your Dataset rules and plan your Search Datasets based on estimated future storage costs.

Instrument Your Application ​

Use OpenInference CrewAIInstrumentor with Python 3.10 through 3.13 and CrewAI 1.10.1+. Also instrument the LLM provider CrewAI actually calls. CrewAI 1.x routes by model-string prefix: native SDKs for openai/..., anthropic/..., gemini/..., azure/..., and bedrock/...; other prefixes typically use LiteLLM unless you set custom_openai=True on LLM.

CrewAI OpenTelemetry export through OpenInference is Python-only. Call CrewAIInstrumentor().instrument() and the matching LLM instrumentor before you import CrewAI or construct LLM clients. See the OpenInference CrewAI instrumentation README for compatibility notes.

Example Applications ​

The examples below use current CrewAI 1.15 APIs with OpenAI. Set your provider API keys before running.

Single agent (minimal):

from crewai import Agent, Crew, LLM, Task

llm = LLM(model="openai/gpt-4o-mini")

agent = Agent(
    role="Observability explainer",
    goal="Explain telemetry concepts in one sentence.",
    backstory="You write concise technical explanations.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)

task = Task(
    description="What is OpenTelemetry? Answer in one sentence.",
    expected_output="One sentence.",
    agent=agent,
)

crew = Crew(agents=[agent], tasks=[task], verbose=False)
print(crew.kickoff())

Sequential crew (two agents):

from crewai import Agent, Crew, LLM, Process, Task

llm = LLM(model="openai/gpt-4o-mini")

researcher = Agent(
    role="Researcher",
    goal="Collect a short factual note.",
    backstory="You research technical topics and keep notes brief.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)

writer = Agent(
    role="Writer",
    goal="Turn research notes into a two-sentence summary.",
    backstory="You write clear prose for a general audience.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)

research_task = Task(
    description="Explain why observability uses traces, metrics, and logs. Name each signal in one clause.",
    expected_output="A short factual paragraph.",
    agent=researcher,
)

write_task = Task(
    description="Using the researcher's notes, produce exactly two sentences. No preamble.",
    expected_output="Exactly two sentences.",
    agent=writer,
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
    verbose=False,
)
print(crew.kickoff())

Tool-calling agent:

from crewai import Agent, Crew, LLM, Task
from crewai.tools import tool

@tool("Add two numbers")
def add_numbers(a: int, b: int) -> int:
    """Add two integers and return the sum."""
    return a + b

llm = LLM(model="openai/gpt-4o-mini")

agent = Agent(
    role="Math assistant",
    goal="Answer arithmetic questions using tools.",
    backstory="You use tools for exact calculations.",
    llm=llm,
    tools=[add_numbers],
    allow_delegation=False,
    verbose=False,
)

task = Task(
    description="What is 20 + 8? Use the tool.",
    expected_output="The numeric sum.",
    agent=agent,
)

crew = Crew(agents=[agent], tasks=[task], verbose=False)
print(crew.kickoff())

Auto-Instrumentation ​

Install the OpenInference CrewAI and provider instrumentors, then run your app under opentelemetry-instrument so crews emit spans with minimal code changes.

1. Install the distro and OpenInference instrumentation packages:

pip install opentelemetry-distro opentelemetry-exporter-otlp \
  openinference-instrumentation-crewai \
  openinference-instrumentation-openai \
  "crewai[openai]>=1.10.1"

If your agents use a different native provider, replace openinference-instrumentation-openai with the matching package (for example openinference-instrumentation-anthropic, openinference-instrumentation-google-genai, or openinference-instrumentation-bedrock). For LiteLLM-routed providers, use openinference-instrumentation-litellm.

2. Optionally, bootstrap additional instrumentation packages:

opentelemetry-bootstrap -a install

3. Run your application with the auto-instrumentor:

opentelemetry-instrument python app.py

The instrumentor reads its configuration from OTEL_* environment variables.

Code-Based Setup ​

Initialize OpenTelemetry, CrewAIInstrumentor, and the matching LLM instrumentor in a dedicated module. Import that module before you import CrewAI or construct LLM clients.

1. Create a tracing.py file:

# tracing.py: import this BEFORE your app code
from openinference.instrumentation.crewai import CrewAIInstrumentor
from openinference.instrumentation.openai import OpenAIInstrumentor
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace.set_tracer_provider(provider)

CrewAIInstrumentor().instrument(tracer_provider=provider)
OpenAIInstrumentor().instrument(tracer_provider=provider)

2. Create an app.py file that imports tracing before any CrewAI calls:

import tracing  # must be first
from crewai import Agent, Crew, LLM, Task

llm = LLM(model="openai/gpt-4o-mini")
agent = Agent(
    role="Observability explainer",
    goal="Explain telemetry concepts in one sentence.",
    backstory="You write concise technical explanations.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)
task = Task(
    description="What is OpenTelemetry? Answer in one sentence.",
    expected_output="One sentence.",
    agent=agent,
)
print(Crew(agents=[agent], tasks=[task], verbose=False).kickoff())

3. Set environment variables and run your application:

python app.py

The exporter reads its endpoint from OTEL_EXPORTER_OTLP_ENDPOINT automatically.

Set Environment Variables ​

Set these environment variables before running your instrumented application. Replace <cribl-host> with your Cribl host address, and <token> with your Bearer token if authentication is enabled on the OTel Source.

Use gRPC (port 4317) ​

Set environment variables using gRPC. This is the recommended method:

export OTEL_EXPORTER_OTLP_ENDPOINT="http://<cribl-host>:4317"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_SERVICE_NAME="my-crewai-app"
export CREWAI_DISABLE_TELEMETRY="true"

# Only if you enabled auth on the Cribl OTEL Source:
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <token>"

Use HTTP/protobuf (port 4318) ​

If your OTLP exporter or network path requires HTTP/protobuf instead of gRPC, use port 4318, set the protocol as shown, and switch the import statement for the exporter in tracing.py to opentelemetry.exporter.otlp.proto.http.trace_exporter.OTLPSpanExporter.

export OTEL_EXPORTER_OTLP_ENDPOINT="http://<cribl-host>:4318"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_SERVICE_NAME="my-crewai-app"
export CREWAI_DISABLE_TELEMETRY="true"

# Only if you enabled auth on the Cribl OTEL Source:
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <token>"

Environment Variable Reference ​

Use this table to set OTLP export options, optional auth headers for the Cribl Source, and provider API keys for the models your CrewAI stack calls.

Capture Prompt/Completion Content ​

OpenInference includes prompt and completion content on spans by default. That can expose sensitive data in your telemetry pipeline.

To hide inputs and outputs at the instrumentor:

export OPENINFERENCE_HIDE_INPUTS="true"
export OPENINFERENCE_HIDE_OUTPUTS="true"

You can also pass a TraceConfig into instrument(). To reduce sensitive content in Cribl Search, filter or redact event fields with Datatype rules, or route through Cribl Stream and use masking Functions before delivery.

Verify Data Flow in Cribl Search ​

After completing the instrumentation process, confirm OTLP events flow from your instrumented app into Cribl Search.

1. On the Cribl.Cloud top bar, select Products > Search > Data > Live Data.
2. Select your OpenTelemetry Source and confirm that events appear while you trigger traffic from your CrewAI application.
3. For full Live Data behavior and troubleshooting, check Live Data.

Common Search Issues and Fixes ​

LLM Telemetry Use Cases ​

With data flowing into Cribl Search, you can explore and gain visibility into your CrewAI telemetry:

• Explore LLM telemetry: Explore your Search Dataset in Cribl Search and query it with KQL. Filter and slice by service, model, environment, token usage, cost signals, and error or status fields.
• Investigate incidents and performance regressions: During elevated errors or latency, investigate your LLM Search Dataset. Use aggregations such as summarize or timestats to break down failures by model, deployment, feature, tenant, or region. Use join or related patterns with infrastructure, gateway, or security Datasets for end-to-end context.
• Build dashboards for LLM usage and cost: Use Cribl Search Dashboards to track requests over time by model or app, token usage and derived cost, error rates by environment or tenant, and latency percentiles (for example P95/P99) plus token distributions and traffic share.
• Automate checks with scheduled searches and notifications: Turn important queries (for example, when estimated LLM cost or error rate crosses a threshold over a time window) into Scheduled Searches and attach Notifications to email, Slack, SNS, webhooks, and other targets.

See more detailed LLM telemetry use cases in Cribl Search.

Learn how to instrument CrewAI applications with OpenTelemetry, export large language model (LLM) telemetry via OTLP, and send it into Cribl Stream. Once data is in Cribl Stream, you can route, mask, and enrich it before it reaches your observability backends.

You’ll complete the following high-level steps:

1. Configure an OpenTelemetry (OTel) Source in Cribl Stream to receive OTLP data.
2. Instrument your CrewAI application (Python) with OpenTelemetry.
3. Explore LLM telemetry use cases for Cribl Stream.

Telemetry Captured ​

CrewAI runs produce trace spans with these attributes:

Semantic conventions follow OpenTelemetry GenAI Semantic Conventions and OpenInference where applicable.

Prerequisites ​

• A Cribl Stream instance (v4.x+) with an OpenTelemetry (OTEL) Source enabled.
• An OpenAI API key or other provider credentials as your CrewAI stack requires (examples below use OpenAI and OPENAI_API_KEY).
• Python 3.10 through 3.13 (current crewai and OpenInference packages do not support Python 3.14).
• CrewAI 1.10.1 or later (current PyPI release is 1.15.x).

Configure the OpenTelemetry (OTel) Source in Cribl Stream ​

Before instrumenting your CrewAI app, configure Cribl Stream to receive OTLP data.

Configure an OTel Source ​

You do not need a separate OpenTelemetry Source for each LLM or agent provider. Configure one OTel Source in Cribl Stream and point all instrumented applications at the same endpoint. Per application, only the service name and provider API key typically differ. Use Routes and Pipelines in Cribl Stream to filter and process events by service.name.

To receive OTLP from your LLM application, add or edit an OpenTelemetry Source on your Worker Group as follows.

1. On the top bar, select Products, and then select Cribl Stream. Under Worker Groups, select a Worker Group. Next, you have two options:

   • To configure via QuickConnect, navigate to Routing > QuickConnect. Select Add Source and select the Source you want from the list, choosing either Select Existing or Add New.
   • To configure via the Routes, select Data > Sources. Select the Source you want. Next, select Add Source.

2. In the New Source modal, configure the following under General Settings:

   • Input ID: Unique ID for this Source. For example, OTel042.
   • Description: Optionally, enter a description.
   • OTLP version: The drop-down offers 0.10.0 and 1.3.1 (default).
   • Protocol: Use the drop-down to choose the protocol matching the data you will ingest: gRPC (default), or HTTP.
   • Address: Enter the hostname/IP to listen on. Defaults to 0.0.0.0 (all addresses, IPv4 format).
   • Port: By default, OTel applications send output to port 4317 when using the gRPC protocol, and port 4318 when using HTTP. This setting defaults to 4317 - you must change it if you set Protocol (below) to HTTP, or you want Cribl Stream to collect data from an OTel application that is using a different port.

   Port 4318 is not available on Cribl-managed Worker Groups in Cribl.Cloud.

   • The Extract spans, Extract metrics, and Extract logs settings are specific to the OpenTelemetry Source. By default, these options are toggled off, allowing Cribl Stream to act as a pass-through that generates a single event for each incoming OTel payload. This is useful when you want to forward complete OTel events to downstream systems, such as persistent storage, without breaking them apart. You can enable these settings to extract and process individual records from within OTel events:
     • Extract spans: Generates an individual event for each span in a trace. Traces typically contain multiple spans.
     • Extract metrics: Generates an individual event for each data point in a metric event. OTel metrics often contain multiple data points per event.
     • Extract logs: Available only when OTLP version is set to 1.3.1. Generates an individual event for each log record. Cribl recommends enabling this option to simplify log transformation and manipulation.
   • Tags: Optionally, add tags to help filter and group Sources within Cribl Stream’s UI. Tags are not included in the event data. Separate tag names using a tab or hard return.

3. Optionally, you can adjust the Authentication, TLS, Persistent Queue Settings, Processing, and Advanced settings, or Connected Destinations.

4. Select Save, then Commit & Deploy.

Instrument Your Application ​

Use OpenInference CrewAIInstrumentor with Python 3.10 through 3.13 and CrewAI 1.10.1+. Also instrument the LLM provider CrewAI actually calls. CrewAI 1.x routes by model-string prefix: native SDKs for openai/..., anthropic/..., gemini/..., azure/..., and bedrock/...; other prefixes typically use LiteLLM unless you set custom_openai=True on LLM.

CrewAI OpenTelemetry export through OpenInference is Python-only. Call CrewAIInstrumentor().instrument() and the matching LLM instrumentor before you import CrewAI or construct LLM clients. See the OpenInference CrewAI instrumentation README for compatibility notes.

Example Applications ​

The examples below use current CrewAI 1.15 APIs with OpenAI. Set your provider API keys before running.

Single agent (minimal):

from crewai import Agent, Crew, LLM, Task

llm = LLM(model="openai/gpt-4o-mini")

agent = Agent(
    role="Observability explainer",
    goal="Explain telemetry concepts in one sentence.",
    backstory="You write concise technical explanations.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)

task = Task(
    description="What is OpenTelemetry? Answer in one sentence.",
    expected_output="One sentence.",
    agent=agent,
)

crew = Crew(agents=[agent], tasks=[task], verbose=False)
print(crew.kickoff())

Sequential crew (two agents):

from crewai import Agent, Crew, LLM, Process, Task

llm = LLM(model="openai/gpt-4o-mini")

researcher = Agent(
    role="Researcher",
    goal="Collect a short factual note.",
    backstory="You research technical topics and keep notes brief.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)

writer = Agent(
    role="Writer",
    goal="Turn research notes into a two-sentence summary.",
    backstory="You write clear prose for a general audience.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)

research_task = Task(
    description="Explain why observability uses traces, metrics, and logs. Name each signal in one clause.",
    expected_output="A short factual paragraph.",
    agent=researcher,
)

write_task = Task(
    description="Using the researcher's notes, produce exactly two sentences. No preamble.",
    expected_output="Exactly two sentences.",
    agent=writer,
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
    verbose=False,
)
print(crew.kickoff())

Tool-calling agent:

from crewai import Agent, Crew, LLM, Task
from crewai.tools import tool

@tool("Add two numbers")
def add_numbers(a: int, b: int) -> int:
    """Add two integers and return the sum."""
    return a + b

llm = LLM(model="openai/gpt-4o-mini")

agent = Agent(
    role="Math assistant",
    goal="Answer arithmetic questions using tools.",
    backstory="You use tools for exact calculations.",
    llm=llm,
    tools=[add_numbers],
    allow_delegation=False,
    verbose=False,
)

task = Task(
    description="What is 20 + 8? Use the tool.",
    expected_output="The numeric sum.",
    agent=agent,
)

crew = Crew(agents=[agent], tasks=[task], verbose=False)
print(crew.kickoff())

Auto-Instrumentation ​

Install the OpenInference CrewAI and provider instrumentors, then run your app under opentelemetry-instrument so crews emit spans with minimal code changes.

1. Install the distro and OpenInference instrumentation packages:

pip install opentelemetry-distro opentelemetry-exporter-otlp \
  openinference-instrumentation-crewai \
  openinference-instrumentation-openai \
  "crewai[openai]>=1.10.1"

If your agents use a different native provider, replace openinference-instrumentation-openai with the matching package (for example openinference-instrumentation-anthropic, openinference-instrumentation-google-genai, or openinference-instrumentation-bedrock). For LiteLLM-routed providers, use openinference-instrumentation-litellm.

2. Optionally, bootstrap additional instrumentation packages:

opentelemetry-bootstrap -a install

3. Run your application with the auto-instrumentor:

opentelemetry-instrument python app.py

The instrumentor reads its configuration from OTEL_* environment variables.

Code-Based Setup ​

Initialize OpenTelemetry, CrewAIInstrumentor, and the matching LLM instrumentor in a dedicated module. Import that module before you import CrewAI or construct LLM clients.

1. Create a tracing.py file:

# tracing.py: import this BEFORE your app code
from openinference.instrumentation.crewai import CrewAIInstrumentor
from openinference.instrumentation.openai import OpenAIInstrumentor
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace.set_tracer_provider(provider)

CrewAIInstrumentor().instrument(tracer_provider=provider)
OpenAIInstrumentor().instrument(tracer_provider=provider)

2. Create an app.py file that imports tracing before any CrewAI calls:

import tracing  # must be first
from crewai import Agent, Crew, LLM, Task

llm = LLM(model="openai/gpt-4o-mini")
agent = Agent(
    role="Observability explainer",
    goal="Explain telemetry concepts in one sentence.",
    backstory="You write concise technical explanations.",
    llm=llm,
    allow_delegation=False,
    verbose=False,
)
task = Task(
    description="What is OpenTelemetry? Answer in one sentence.",
    expected_output="One sentence.",
    agent=agent,
)
print(Crew(agents=[agent], tasks=[task], verbose=False).kickoff())

3. Set environment variables and run your application:

python app.py

The exporter reads its endpoint from OTEL_EXPORTER_OTLP_ENDPOINT automatically.

Set Environment Variables ​

Set these environment variables before running your instrumented application. Replace <cribl-host> with your Cribl host address, and <token> with your Bearer token if authentication is enabled on the OTel Source.

Use gRPC (port 4317) ​

Set environment variables using gRPC. This is the recommended method:

export OTEL_EXPORTER_OTLP_ENDPOINT="http://<cribl-host>:4317"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_SERVICE_NAME="my-crewai-app"
export CREWAI_DISABLE_TELEMETRY="true"

# Only if you enabled auth on the Cribl OTEL Source:
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <token>"

Use HTTP/protobuf (port 4318) ​

If your OTLP exporter or network path requires HTTP/protobuf instead of gRPC, use port 4318, set the protocol as shown, and switch the import statement for the exporter in tracing.py to opentelemetry.exporter.otlp.proto.http.trace_exporter.OTLPSpanExporter.

export OTEL_EXPORTER_OTLP_ENDPOINT="http://<cribl-host>:4318"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_SERVICE_NAME="my-crewai-app"
export CREWAI_DISABLE_TELEMETRY="true"

# Only if you enabled auth on the Cribl OTEL Source:
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <token>"

Environment Variable Reference ​

Use this table to set OTLP export options, optional auth headers for the Cribl Source, and provider API keys for the models your CrewAI stack calls.

Capture Prompt/Completion Content ​

OpenInference includes prompt and completion content on spans by default. That can expose sensitive data in your telemetry pipeline. Use Cribl Stream’s masking and redaction functions to sanitize data before routing to downstream destinations.

To hide inputs and outputs at the instrumentor:

export OPENINFERENCE_HIDE_INPUTS="true"
export OPENINFERENCE_HIDE_OUTPUTS="true"

You can also pass a TraceConfig into instrument().

Verify Data Flow in Cribl Stream ​

After completing the instrumentation process, confirm OTLP events flow from your instrumented app into Cribl Stream.

1. In Cribl Stream, go to Monitoring > Sources and select your OTel Source.
2. Open the Live Data tab.
3. Select Start Capture.
4. Trigger a request in your CrewAI application.
5. Confirm that events appear in Live Data for your OTel Source.

Route Data to Cribl Search ​

After CrewAI OTLP data reaches Cribl Stream, add a Cribl Search Destination so you can explore and investigate LLM telemetry to troubleshoot issues, analyze model behavior, and monitor performance. See the Cribl Search Destination guide for setup instructions.

Common Stream Issues and Fixes ​

If spans are missing or the exporter cannot reach Cribl Stream, use this table to narrow down endpoint, authentication, TLS, library versions, and how instrumentation is loaded.

LLM Telemetry Use Cases ​

With data flowing into Cribl Stream, you can route CrewAI telemetry to any supported Destination. For example:

• Cribl Search: Search and analyze full-fidelity LLM traces and logs interactively.
• Cribl Lake: Store and search traces natively with partitioning optimized for Cribl Search, so you can query CrewAI traces at scale without re-ingesting them into a separate system.
• Amazon S3 or other object storage: Archive traces for compliance or long-term analysis using partitioning schemes aligned with Cribl Search, so you can query data in place without moving it.
• OpenTelemetry: Forward LLM traces in standard OTLP format to downstream systems.

To set up routing:

1. Add Routes in Routing > Data Routes to match OTel data and direct it to your chosen Destinations.
2. Go to Processing > Pipelines and create a Pipeline to process data flowing down your Route.
3. Use Functions to enrich, filter, sample, or redact data before delivery. For example:
   • Mask prompt/completion content containing sensitive information.
   • Sample high-volume traces to reduce cost.
   • Aggregate token usage metrics by model or service.

For more detailed LLM telemetry use cases, see LLM Telemetry Use Cases in Cribl.