From 86b5977988055b65da3f3a23e32c72e5233d0cc0 Mon Sep 17 00:00:00 2001 From: julian-risch <4181769+julian-risch@users.noreply.github.com> Date: Tue, 23 Jun 2026 13:02:11 +0000 Subject: [PATCH] Sync Core Integrations API reference (opentelemetry) on Docusaurus --- .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ .../integrations-api/opentelemetry.md | 202 ++++++++++++++++++ 14 files changed, 2828 insertions(+) create mode 100644 docs-website/reference/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.18/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.19/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.20/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.21/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.22/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.23/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.24/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.25/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.26/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.27/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.28/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.29/integrations-api/opentelemetry.md create mode 100644 docs-website/reference_versioned_docs/version-2.30/integrations-api/opentelemetry.md diff --git a/docs-website/reference/integrations-api/opentelemetry.md b/docs-website/reference/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.18/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.18/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.18/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.19/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.19/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.19/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.20/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.20/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.20/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.21/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.21/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.21/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.22/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.22/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.22/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.23/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.23/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.23/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.24/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.24/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.24/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.25/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.25/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.25/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.26/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.26/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.26/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.27/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.27/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.27/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.28/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.28/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.28/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.29/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.29/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.29/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span diff --git a/docs-website/reference_versioned_docs/version-2.30/integrations-api/opentelemetry.md b/docs-website/reference_versioned_docs/version-2.30/integrations-api/opentelemetry.md new file mode 100644 index 00000000000..89aba50ee58 --- /dev/null +++ b/docs-website/reference_versioned_docs/version-2.30/integrations-api/opentelemetry.md @@ -0,0 +1,202 @@ +--- +title: "OpenTelemetry" +id: integrations-opentelemetry +description: "OpenTelemetry integration for Haystack" +slug: "/integrations-opentelemetry" +--- + + +## haystack_integrations.components.connectors.opentelemetry.opentelemetry_connector + +### OpenTelemetryConnector + +OpenTelemetryConnector connects Haystack to [OpenTelemetry](https://opentelemetry.io/) in order to enable the + +tracing of operations and data flow within the components of a pipeline. + +To use the OpenTelemetryConnector, add it to your pipeline without connecting it to any other component. It will +automatically trace all pipeline operations when tracing is enabled. Make sure to configure an OpenTelemetry +`TracerProvider` (for example, with an exporter) before initializing the connector. + +**Environment Configuration:** + +- `HAYSTACK_CONTENT_TRACING_ENABLED`: Must be set to `"true"` to trace the content (inputs and outputs) of the + pipeline components. + +Here is an example of how to use the OpenTelemetryConnector in a pipeline: + +```python +import os + +os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true" + +from opentelemetry import trace +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.sdk.resources import Resource +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import BatchSpanProcessor +from opentelemetry.semconv.resource import ResourceAttributes + +# Configure the OpenTelemetry SDK. A service name is required for most backends. +resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "haystack"}) +tracer_provider = TracerProvider(resource=resource) +processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")) +tracer_provider.add_span_processor(processor) +trace.set_tracer_provider(tracer_provider) + +from haystack import Pipeline +from haystack.components.builders import ChatPromptBuilder +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.dataclasses import ChatMessage +from haystack_integrations.components.connectors.opentelemetry import OpenTelemetryConnector + +pipe = Pipeline() +pipe.add_component("tracer", OpenTelemetryConnector()) +pipe.add_component("prompt_builder", ChatPromptBuilder()) +pipe.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini")) + +pipe.connect("prompt_builder.prompt", "llm.messages") + +messages = [ + ChatMessage.from_system("Always respond in German even if some input data is in other languages."), + ChatMessage.from_user("Tell me about {{location}}"), +] + +response = pipe.run( + data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}} +) +print(response["llm"]["replies"][0]) +``` + +#### __init__ + +```python +__init__(name: str = 'opentelemetry') -> None +``` + +Initialize the OpenTelemetryConnector component. + +**Parameters:** + +- **name** (str) – The name used to identify this tracing component. It is returned by the `run` method and can be + used to mark traces produced by this connector. + +#### run + +```python +run() -> dict[str, str] +``` + +Runs the OpenTelemetryConnector component. + +**Returns:** + +- dict\[str, str\] – A dictionary with the following keys: +- `name`: The name of the tracing component. + +#### to_dict + +```python +to_dict() -> dict[str, Any] +``` + +Serialize this component to a dictionary. + +**Returns:** + +- dict\[str, Any\] – The serialized component as a dictionary. + +#### from_dict + +```python +from_dict(data: dict[str, Any]) -> OpenTelemetryConnector +``` + +Deserialize this component from a dictionary. + +**Parameters:** + +- **data** (dict\[str, Any\]) – The dictionary representation of this component. + +**Returns:** + +- OpenTelemetryConnector – The deserialized component instance. + +## haystack_integrations.tracing.opentelemetry.tracer + +### OpenTelemetrySpan + +Bases: Span + +#### __init__ + +```python +__init__(span: opentelemetry.trace.Span) -> None +``` + +Creates an instance of OpenTelemetrySpan. + +#### set_tag + +```python +set_tag(key: str, value: Any) -> None +``` + +Set a single tag on the span. + +**Parameters:** + +- **key** (str) – the name of the tag. +- **value** (Any) – the value of the tag. + +#### raw_span + +```python +raw_span() -> Any +``` + +Provides access to the underlying span object of the tracer. + +**Returns:** + +- Any – The underlying span object. + +#### get_correlation_data_for_logs + +```python +get_correlation_data_for_logs() -> dict[str, Any] +``` + +Return a dictionary with correlation data for logs. + +### OpenTelemetryTracer + +Bases: Tracer + +#### __init__ + +```python +__init__(tracer: opentelemetry.trace.Tracer) -> None +``` + +Creates an instance of OpenTelemetryTracer. + +#### trace + +```python +trace( + operation_name: str, + tags: dict[str, Any] | None = None, + parent_span: Span | None = None, +) -> Iterator[Span] +``` + +Activate and return a new span that inherits from the current active span. + +#### current_span + +```python +current_span() -> Span | None +``` + +Return the current active span