docs(ollama,together,replicate,sagemaker,bedrock): add missing docstrings to reach 80% coverage

Adds one-line docstrings to all functions that were missing them across
the five LLM instrumentation packages. This brings docstring coverage
from ~14-18% to 100% per file, satisfying CodeRabbit's 80% threshold.

Author: Koushik-Salammagari

packages/opentelemetry-instrumentation-bedrock/opentelemetry/instrumentation/bedrock/__init__.py

@@ -82,6 +82,7 @@ def __init__(
         guardrail_words: Counter,
         prompt_caching: Counter,
     ):
+        """Initialize the instrumentor and apply configuration settings."""
         self.vendor = ""
         self.model = ""
         self.is_stream = False
@@ -120,6 +121,7 @@ def _span_name(operation_name, model):
 
 
 def is_metrics_enabled() -> bool:
+    """Return True if metrics collection is enabled via environment variable."""
     return (os.getenv("TRACELOOP_METRICS_ENABLED") or "true").lower() == "true"
 
 
@@ -132,7 +134,9 @@ def _with_tracer(
         event_logger,
         to_wrap,
     ):
+        """Bind tracer and configuration parameters, returning the wrapped function factory."""
         def wrapper(wrapped, instance, args, kwargs):
+            """Invoke the instrumented function with bound tracer parameters."""
             return func(
                 tracer,
                 metric_params,
@@ -206,8 +210,10 @@ def _wrap(
 
 
 def _instrumented_model_invoke(fn, tracer, metric_params, event_logger):
+    """Wrap invoke_model to create a span and record exceptions."""
     @wraps(fn)
     def with_instrumentation(*args, **kwargs):
+        """Execute the wrapped AWS API call within an OTel span."""
         if context_api.get_value(SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY):
             return fn(*args, **kwargs)
 
@@ -240,8 +246,10 @@ def with_instrumentation(*args, **kwargs):
 def _instrumented_model_invoke_with_response_stream(
     fn, tracer, metric_params, event_logger
 ):
+    """Wrap invoke_model_with_response_stream to create a span and record exceptions."""
     @wraps(fn)
     def with_instrumentation(*args, **kwargs):
+        """Execute the wrapped AWS API call within an OTel span."""
         if context_api.get_value(SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY):
             return fn(*args, **kwargs)
 
@@ -276,8 +284,10 @@ def _instrumented_converse(fn, tracer, metric_params, event_logger):
     # see
     # https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-runtime/client/converse.html
     # for the request/response format
+    """Wrap converse to create a span and record exceptions."""
     @wraps(fn)
     def with_instrumentation(*args, **kwargs):
+        """Execute the wrapped AWS API call within an OTel span."""
         if context_api.get_value(SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY):
             return fn(*args, **kwargs)
 
@@ -308,8 +318,10 @@ def with_instrumentation(*args, **kwargs):
 
 
 def _instrumented_converse_stream(fn, tracer, metric_params, event_logger):
+    """Wrap converse_stream to create a span and record exceptions."""
     @wraps(fn)
     def with_instrumentation(*args, **kwargs):
+        """Execute the wrapped AWS API call within an OTel span."""
         if context_api.get_value(SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY):
             return fn(*args, **kwargs)
 
@@ -342,6 +354,7 @@ def with_instrumentation(*args, **kwargs):
 @dont_throw
 def _handle_stream_call(span, kwargs, response, metric_params, event_logger):
 
+    """Attach a StreamingWrapper to the response body to finalize the span when streaming completes."""
     (provider, model_vendor, model) = _get_vendor_model(kwargs.get("modelId"))
     request_body = json.loads(kwargs.get("body"))
 
@@ -352,6 +365,7 @@ def _handle_stream_call(span, kwargs, response, metric_params, event_logger):
     @dont_throw
     def stream_done(response_body):
 
+        """Finalize span attributes when the streaming response body is fully consumed."""
         metric_params.vendor = provider
         metric_params.model = model
         metric_params.is_stream = True
@@ -388,6 +402,7 @@ def stream_done(response_body):
 
 @dont_throw
 def _handle_call(span: Span, kwargs, response, metric_params, event_logger):
+    """Read and record request/response attributes on the current span for a non-streaming call."""
     response["body"] = ReusableStreamingBody(
         response["body"]._raw_stream, response["body"]._content_length
     )
@@ -429,6 +444,7 @@ def _handle_call(span: Span, kwargs, response, metric_params, event_logger):
 
 @dont_throw
 def _handle_converse(span, kwargs, response, metric_params, event_logger):
+    """Record converse request/response attributes on the current span."""
     (provider, model_vendor, model) = _get_vendor_model(kwargs.get("modelId"))
     guardrail_converse(span, response, provider, model, metric_params)
 
@@ -447,6 +463,7 @@ def _handle_converse(span, kwargs, response, metric_params, event_logger):
 
 @dont_throw
 def _handle_converse_stream(span, kwargs, response, metric_params, event_logger):
+    """Attach streaming event handler to record converse_stream response attributes."""
     (provider, model_vendor, model) = _get_vendor_model(kwargs.get("modelId"))
 
     set_converse_model_span_attributes(span, provider, model, kwargs)
@@ -461,7 +478,9 @@ def _handle_converse_stream(span, kwargs, response, metric_params, event_logger)
     if stream:
 
         def handler(func):
+            """Decorate the stream event parser to accumulate response content and record span attributes."""
             def wrap(*args, **kwargs):
+                """Process each stream event, accumulate content, and record span attributes on completion."""
                 response_msg = kwargs.pop("response_msg")
                 tool_blocks = kwargs.pop("tool_blocks")
                 reasoning_blocks = kwargs.pop("reasoning_blocks")
@@ -522,6 +541,7 @@ def wrap(*args, **kwargs):
 def _get_vendor_model(modelId):
     # Docs:
     # https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html#inference-profiles-support-system
+    """Parse modelId to extract provider, model vendor, and model name."""
     provider = GenAiSystemValues.AWS_BEDROCK.value
     model_vendor = "imported_model"
     model = modelId
@@ -540,6 +560,7 @@ def _get_vendor_model(modelId):
 
 
 def _cross_region_check(value):
+    """Strip cross-region inference prefix from a model identifier string."""
     prefixes = ["us", "us-gov", "eu", "apac"]
     if any(value.startswith(prefix + ".") for prefix in prefixes):
         parts = value.split(".")
@@ -580,6 +601,7 @@ class PromptCaching:
 
 
 def _create_metrics(meter: Meter):
+    """Create and return OTel metric instruments for Bedrock token usage, duration, and guardrails."""
     token_histogram = meter.create_histogram(
         name=Meters.LLM_TOKEN_USAGE,
         unit="token",
@@ -679,15 +701,18 @@ def __init__(
         exception_logger=None,
         use_legacy_attributes: bool = True,
     ):
+        """Initialize the instrumentor and apply configuration settings."""
         super().__init__()
         Config.enrich_token_usage = enrich_token_usage
         Config.exception_logger = exception_logger
         Config.use_legacy_attributes = use_legacy_attributes
 
     def instrumentation_dependencies(self) -> Collection[str]:
+        """Return the package version constraints required by this instrumentor."""
         return _instruments
 
     def _instrument(self, **kwargs):
+        """Patch the target library to add OTel instrumentation."""
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
 
@@ -764,6 +789,7 @@ def _instrument(self, **kwargs):
             )
 
     def _uninstrument(self, **kwargs):
+        """Remove OTel instrumentation patches from the target library."""
         for wrapped_method in WRAPPED_METHODS:
             wrap_package = wrapped_method.get("package")
             wrap_object = wrapped_method.get("object")

packages/opentelemetry-instrumentation-ollama/opentelemetry/instrumentation/ollama/__init__.py

@@ -65,6 +65,7 @@
 
 def _sanitize_copy_messages(wrapped, instance, args, kwargs):
     # original signature: _copy_messages(messages)
+    """Sanitize tool_calls arguments in messages before Pydantic validation."""
     messages = args[0] if args else []
     sanitized = []
     for msg in messages or []:
@@ -96,6 +97,7 @@ def _accumulate_streaming_response(
     streaming_time_to_generate=None,
     start_time=None,
 ):
+    """Yield streaming response chunks and record span attributes on completion."""
     if llm_request_type == LLMRequestTypeValues.CHAT:
         accumulated_response = {"message": {"content": "", "role": ""}}
     elif llm_request_type == LLMRequestTypeValues.COMPLETION:
@@ -160,6 +162,7 @@ async def _aaccumulate_streaming_response(
     streaming_time_to_generate=None,
     start_time=None,
 ):
+    """Async version: yield streaming response chunks and record span attributes on completion."""
     if llm_request_type == LLMRequestTypeValues.CHAT:
         accumulated_response = {"message": {"content": "", "role": ""}}
     elif llm_request_type == LLMRequestTypeValues.COMPLETION:
@@ -226,7 +229,9 @@ def _with_tracer(
         streaming_time_to_generate,
         to_wrap,
     ):
+        """Bind tracer and configuration parameters, returning the wrapped function factory."""
         def wrapper(wrapped, instance, args, kwargs):
+            """Invoke the instrumented function with bound tracer parameters."""
             return func(
                 tracer,
                 token_histogram,
@@ -247,6 +252,7 @@ def wrapper(wrapped, instance, args, kwargs):
 
 
 def _llm_request_type_by_method(method_name):
+    """Return the LLMRequestTypeValues enum for a given Together AI method name."""
     if method_name == "chat":
         return LLMRequestTypeValues.CHAT
     elif method_name == "generate":
@@ -259,6 +265,7 @@ def _llm_request_type_by_method(method_name):
 
 @dont_throw
 def _handle_input(span, event_logger, llm_request_type, args, kwargs):
+    """Set prompt span attributes and emit prompt events if event logging is enabled."""
     set_model_input_attributes(span, kwargs)
     if should_emit_events() and event_logger:
         emit_message_events(llm_request_type, args, kwargs, event_logger)
@@ -268,6 +275,7 @@ def _handle_input(span, event_logger, llm_request_type, args, kwargs):
 
 @dont_throw
 def _handle_response(span, event_logger, llm_request_type, token_histogram, response):
+    """Set response span attributes and emit choice events if event logging is enabled."""
     if should_emit_events() and event_logger:
         emit_choice_events(llm_request_type, response, event_logger)
     else:
@@ -437,6 +445,7 @@ async def _awrap(
 
 
 def _build_metrics(meter: Meter):
+    """Create and return OTel metric instruments for token usage, duration, and streaming timing."""
     token_histogram = meter.create_histogram(
         name=Meters.LLM_TOKEN_USAGE,
         unit="token",
@@ -465,21 +474,25 @@ def _build_metrics(meter: Meter):
 
 
 def is_metrics_collection_enabled() -> bool:
+    """Return True if metrics collection is enabled via environment variable."""
     return (os.getenv("TRACELOOP_METRICS_ENABLED") or "true").lower() == "true"
 
 
 class OllamaInstrumentor(BaseInstrumentor):
     """An instrumentor for Ollama's client library."""
 
     def __init__(self, exception_logger=None, use_legacy_attributes=True):
+        """Initialize the instrumentor and apply configuration settings."""
         super().__init__()
         Config.exception_logger = exception_logger
         Config.use_legacy_attributes = use_legacy_attributes
 
     def instrumentation_dependencies(self) -> Collection[str]:
+        """Return the package version constraints required by this instrumentor."""
         return _instruments
 
     def _instrument(self, **kwargs):
+        """Patch the target library to add OTel instrumentation."""
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
 
@@ -551,6 +564,7 @@ def _instrument(self, **kwargs):
         )
 
     def _uninstrument(self, **kwargs):
+        """Remove OTel instrumentation patches from the target library."""
         try:
             import ollama
             from ollama._client import AsyncClient, Client
@@ -572,7 +586,9 @@ def _dispatch_wrap(
     streaming_time_to_first_token,
     streaming_time_to_generate
 ):
+    """Return a wrapt wrapper that dispatches sync Ollama _request calls to _wrap."""
     def wrapper(wrapped, instance, args, kwargs):
+        """Invoke the instrumented function with bound tracer parameters."""
         to_wrap = None
         if len(args) > 2 and isinstance(args[2], str):
             path = args[2]
@@ -601,7 +617,9 @@ def _dispatch_awrap(
     streaming_time_to_first_token,
     streaming_time_to_generate,
 ):
+    """Return a wrapt wrapper that dispatches async Ollama _request calls to _awrap."""
     async def wrapper(wrapped, instance, args, kwargs):
+        """Invoke the instrumented function with bound tracer parameters."""
         to_wrap = None
         if len(args) > 2 and isinstance(args[2], str):
             path = args[2]

packages/opentelemetry-instrumentation-replicate/opentelemetry/instrumentation/replicate/__init__.py

@@ -56,10 +56,12 @@
 
 
 def is_streaming_response(response):
+    """Return True if the response is a generator (streaming)."""
     return isinstance(response, types.GeneratorType)
 
 
 def _build_from_streaming_response(span, event_logger, response):
+    """Yield streaming response items and finalize span on completion."""
     complete_response = ""
     for item in response:
         item_to_yield = item
@@ -74,6 +76,7 @@ def _build_from_streaming_response(span, event_logger, response):
 
 @dont_throw
 def _handle_request(span, event_logger, args, kwargs):
+    """Set model input span attributes and emit input events if event logging is enabled."""
     set_model_input_attributes(span, args, kwargs)
 
     model_input = kwargs.get("input") or (args[1] if len(args) > 1 else None)
@@ -86,6 +89,7 @@ def _handle_request(span, event_logger, args, kwargs):
 
 @dont_throw
 def _handle_response(span, event_logger, response):
+    """Set response span attributes and emit choice events if event logging is enabled."""
     if should_emit_events() and event_logger:
         emit_choice_events(response, event_logger)
     else:
@@ -99,7 +103,9 @@ def _with_tracer_wrapper(func):
     """Helper for providing tracer for wrapper functions."""
 
     def _with_tracer(tracer, event_logger, to_wrap):
+        """Bind tracer and configuration parameters, returning the wrapped function factory."""
         def wrapper(wrapped, instance, args, kwargs):
+            """Invoke the instrumented function with bound tracer parameters."""
             return func(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs)
 
         return wrapper
@@ -155,14 +161,17 @@ class ReplicateInstrumentor(BaseInstrumentor):
     """An instrumentor for Replicate's client library."""
 
     def __init__(self, exception_logger=None, use_legacy_attributes=True):
+        """Initialize the instrumentor and apply configuration settings."""
         super().__init__()
         Config.exception_logger = exception_logger
         Config.use_legacy_attributes = use_legacy_attributes
 
     def instrumentation_dependencies(self) -> Collection[str]:
+        """Return the package version constraints required by this instrumentor."""
         return _instruments
 
     def _instrument(self, **kwargs):
+        """Patch the target library to add OTel instrumentation."""
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
 
@@ -181,6 +190,7 @@ def _instrument(self, **kwargs):
             )
 
     def _uninstrument(self, **kwargs):
+        """Remove OTel instrumentation patches from the target library."""
         import replicate
 
         for wrapper_method in WRAPPED_METHODS: