OpenTelemetry Scikit-learn Instrumentation

Common errors

• ModuleNotFoundError: No module named 'sklearn'

  cause The `opentelemetry-instrumentation-sklearn` package requires `scikit-learn` to be installed, but it is missing from the environment.
  fix Install scikit-learn: `pip install scikit-learn`

• Sklearn operations are not being traced/no spans are generated.

  cause The `SklearnInstrumentor().instrument()` call was made after `sklearn` modules or objects were already imported and initialized, or OpenTelemetry SDK was not properly configured.
  fix Ensure `SklearnInstrumentor().instrument()` is called as early as possible in your application's startup, ideally before any `import sklearn` statements. Also, verify that a `TracerProvider` and `SpanProcessor` are correctly configured and set as the global trace provider.

• ERROR: opentelemetry-instrumentation-sklearn 0.46b0 requires scikit-learn>=0.24.0,<1.4.0, but you have scikit-learn 1.4.1 which is incompatible.

  cause A version conflict exists between the installed `scikit-learn` and the versions supported by `opentelemetry-instrumentation-sklearn`.
  fix Adjust your `scikit-learn` version to be within the compatible range specified by `opentelemetry-instrumentation-sklearn` (e.g., `pip install 'scikit-learn<1.4.0'` or `pip install 'scikit-learn>=0.24.0,<1.4.0'` for this example).

Warnings

• gotcha The OpenTelemetry instrumentation should be initialized before the `sklearn` library is imported to ensure proper monkey-patching and tracing of operations. Importing `sklearn` components before calling `SklearnInstrumentor().instrument()` may result in untraced operations.
  Fix: Call `SklearnInstrumentor().instrument()` at the very beginning of your application's entry point, before any `import sklearn` statements or direct usage of scikit-learn objects.
• breaking A change in OpenTelemetry Python Contrib (around v0.53b0 / 1.32.0) altered how dependency checks are performed. Instrumentors now check for the instrumented library's presence and version *inside* the `instrument()` method. If the target library (scikit-learn in this case) is not installed, or its version is incompatible, `instrument()` may raise an `ImportError` or other exceptions.
  Fix: Ensure `scikit-learn` is installed and meets the version requirements of the `opentelemetry-instrumentation-sklearn` package. Review the `instrumentation_dependencies()` method in the source code or the OpenTelemetry documentation for precise version constraints.
• gotcha Running multiple OpenTelemetry SDK components (e.g., multiple exporters or processors) can lead to duplicate telemetry. This is especially problematic in environments like 'Always On' Azure Functions or applications using pre-fork servers where processes might persist or get duplicated.
  Fix: Ensure only one instance of each OpenTelemetry exporter and processor is configured per telemetry signal (traces, metrics, logs) within your application's lifecycle. For pre-fork servers, consider programmatic auto-instrumentation or using a single worker for telemetry-sensitive operations to avoid issues with background threads and locks.

Install

• pip install opentelemetry-instrumentation-sklearn Install core instrumentation
• pip install 'opentelemetry-distro[otlp]' opentelemetry-instrumentation-sklearn Install with OTLP exporter and distro

Imports

• SklearnInstrumentor

  from opentelemetry.instrumentation.sklearn import SklearnInstrumentor

Quickstart

This quickstart demonstrates how to instrument scikit-learn operations. It sets up a basic OpenTelemetry ConsoleSpanExporter to print traces to the console, initializes the `SklearnInstrumentor`, and then performs typical scikit-learn `fit` and `predict` operations. You should see spans generated for these activities in your console output.

from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
from opentelemetry.instrumentation.sklearn import SklearnInstrumentor

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Configure OpenTelemetry Tracer
resource = Resource.create({"service.name": "sklearn-app"})
provider = TracerProvider(resource=resource)
processor = SimpleSpanProcessor(ConsoleSpanExporter())
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

# Initialize Sklearn Instrumentation
# Ensure this is called BEFORE importing sklearn if using programmatic instrumentation
SklearnInstrumentor().instrument()

# Scikit-learn operations will now be traced
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LogisticRegression(max_iter=200)

print("\n--- Training Model ---")
model.fit(X_train, y_train)
print("Model training complete.")

print("\n--- Making Predictions ---")
predictions = model.predict(X_test)
print("Predictions made.")