opik 1.9.38__tar.gz → 1.9.54__tar.gz

{opik-1.9.38/src/opik.egg-info → opik-1.9.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opik
-Version: 1.9.38
+Version: 1.9.54
 Summary: Comet tool for logging and evaluating LLM traces
 Home-page: https://www.comet.com
 Author: Comet ML Inc.
@@ -27,7 +27,7 @@ Requires-Dist: boto3-stubs[bedrock-runtime]>=1.34.110
 Requires-Dist: click
 Requires-Dist: httpx
 Requires-Dist: rapidfuzz<4.0.0,>=3.0.0
-Requires-Dist: litellm!=1.75.0,!=1.75.1,!=1.75.2,!=1.75.3,!=1.75.4,!=1.75.5,!=1.77.3,!=1.77.4,!=1.77.5,!=1.77.7,!=1.78.0,!=1.78.2,!=1.78.3,!=1.78.4,!=1.78.5,!=1.78.6,!=1.78.7,!=1.79.0,!=1.79.1,>=1.79.2
+Requires-Dist: litellm!=1.75.0,!=1.75.1,!=1.75.2,!=1.75.3,!=1.75.4,!=1.75.5,!=1.77.3,!=1.77.4,!=1.77.5,!=1.77.7,!=1.78.0,!=1.78.2,!=1.78.3,!=1.78.4,!=1.78.5,!=1.78.6,!=1.78.7,!=1.79.0,!=1.79.1,!=1.80.9,>=1.79.2
 Requires-Dist: openai
 Requires-Dist: pydantic-settings!=2.9.0,<3.0.0,>=2.0.0
 Requires-Dist: pydantic<3.0.0,>=2.0.0
@@ -70,9 +70,9 @@ Dynamic: summary
         Opik
     </div>
 </h1>
-<h2 align="center" style="border-bottom: none">Open-source LLM evaluation platform</h2>
+<h2 align="center" style="border-bottom: none">Open-source AI Observability, Evaluation, and Optimization</h2>
 <p align="center">
-Opik helps you build, evaluate, and optimize LLM systems that run better, faster, and cheaper. From RAG chatbots to code assistants to complex agentic pipelines, Opik provides comprehensive tracing, evaluations, dashboards, and powerful features like <b>Opik Agent Optimizer</b> and <b>Opik Guardrails</b> to improve and secure your LLM powered applications in production.
+Opik helps you build, test, and optimize generative AI application that run better, from prototype to production.  From RAG chatbots to code assistants to complex agentic systems, Opik provides comprehensive tracing, evaluation, and automatic prompt and tool optimization to take the guesswork out of AI development.
 </p>
 
 <div align="center">
@@ -215,7 +215,7 @@ For production or larger-scale self-hosted deployments, Opik can be installed on
 
 ## 💻 Opik Client SDK
 
-Opik provides a suite of client libraries and a REST API to interact with the Opik server. This includes SDKs for Python, TypeScript, and Ruby (via OpenTelemetry), allowing for seamless integration into your workflows. For detailed API and SDK references, see the [Opik Client Reference Documentation](apps/opik-documentation/documentation/fern/docs/reference/overview.mdx).
+Opik provides a suite of client libraries and a REST API to interact with the Opik server. This includes SDKs for Python, TypeScript, and Ruby (via OpenTelemetry), allowing for seamless integration into your workflows. For detailed API and SDK references, see the [Opik Client Reference Documentation](https://www.comet.com/docs/opik/reference/overview?from=llm&utm_source=opik&utm_medium=github&utm_content=reference_link&utm_campaign=opik).
 
 ### Python SDK Quick Start
 
@@ -238,7 +238,7 @@ opik configure
 ```
 
 > [!TIP]
-> You can also call `opik.configure(use_local=True)` from your Python code to configure the SDK to run on a local self-hosted installation, or provide API key and workspace details directly for Comet.com. Refer to the [Python SDK documentation](apps/opik-documentation/documentation/fern/docs/reference/python-sdk/) for more configuration options.
+> You can also call `opik.configure(use_local=True)` from your Python code to configure the SDK to run on a local self-hosted installation, or provide API key and workspace details directly for Comet.com. Refer to the [Python SDK documentation](https://www.comet.com/docs/opik/python-sdk-reference/?from=llm&utm_source=opik&utm_medium=github&utm_content=python_sdk_docs_link&utm_campaign=opik) for more configuration options.
 
 You are now ready to start logging traces using the [Python SDK](https://www.comet.com/docs/opik/python-sdk-reference/?from=llm&utm_source=opik&utm_medium=github&utm_content=sdk_link2&utm_campaign=opik).
 
@@ -272,6 +272,7 @@ The easiest way to log traces is to use one of our direct integrations. Opik sup
 | Groq                  | Log traces for Groq LLM calls                           | [Documentation](https://www.comet.com/docs/opik/integrations/groq?utm_source=opik&utm_medium=github&utm_content=groq_link&utm_campaign=opik)                                   |
 | Guardrails            | Log traces for Guardrails AI validations                | [Documentation](https://www.comet.com/docs/opik/integrations/guardrails-ai?utm_source=opik&utm_medium=github&utm_content=guardrails_link&utm_campaign=opik)                    |
 | Haystack              | Log traces for Haystack calls                           | [Documentation](https://www.comet.com/docs/opik/integrations/haystack?utm_source=opik&utm_medium=github&utm_content=haystack_link&utm_campaign=opik)                           |
+| Harbor                | Log traces for Harbor benchmark evaluation trials       | [Documentation](https://www.comet.com/docs/opik/integrations/harbor?utm_source=opik&utm_medium=github&utm_content=harbor_link&utm_campaign=opik)                               |
 | Instructor            | Log traces for LLM calls made with Instructor           | [Documentation](https://www.comet.com/docs/opik/integrations/instructor?utm_source=opik&utm_medium=github&utm_content=instructor_link&utm_campaign=opik)                       |
 | LangChain (Python)    | Log traces for LangChain LLM calls                      | [Documentation](https://www.comet.com/docs/opik/integrations/langchain?utm_source=opik&utm_medium=github&utm_content=langchain_link&utm_campaign=opik)                         |
 | LangChain (JS/TS)     | Log traces for LangChain JavaScript/TypeScript calls    | [Documentation](https://www.comet.com/docs/opik/integrations/langchainjs?utm_source=opik&utm_medium=github&utm_content=langchainjs_link&utm_campaign=opik)                     |

{opik-1.9.38 → opik-1.9.54}/setup.py

@@ -48,8 +48,10 @@ setup(
         #   See: https://github.com/BerriAI/litellm/issues/14762
         # - Exclude versions 1.77.5-1.79.1: remove trace_id/parent_span_id passthrough, fixed in 1.79.2+
         #   See: https://github.com/BerriAI/litellm/pull/15529
+        # - Exclude version 1.80.9: broken python 3.9 installation.
+        #   See: https://github.com/BerriAI/litellm/issues/17701
         # Please keep this list in sync with the one in sdks/opik_optimizer/pyproject.toml
-        "litellm>=1.79.2,!=1.75.0,!=1.75.1,!=1.75.2,!=1.75.3,!=1.75.4,!=1.75.5,!=1.77.3,!=1.77.4,!=1.77.5,!=1.77.7,!=1.78.0,!=1.78.2,!=1.78.3,!=1.78.4,!=1.78.5,!=1.78.6,!=1.78.7,!=1.79.0,!=1.79.1",
+        "litellm>=1.79.2,!=1.75.0,!=1.75.1,!=1.75.2,!=1.75.3,!=1.75.4,!=1.75.5,!=1.77.3,!=1.77.4,!=1.77.5,!=1.77.7,!=1.78.0,!=1.78.2,!=1.78.3,!=1.78.4,!=1.78.5,!=1.78.6,!=1.78.7,!=1.79.0,!=1.79.1,!=1.80.9",
         "openai",
         "pydantic-settings>=2.0.0,<3.0.0,!=2.9.0",
         "pydantic>=2.0.0,<3.0.0",

opik-1.9.54/src/opik/api_objects/attachment/attachment_context.py

@@ -0,0 +1,36 @@
+import dataclasses
+from typing import Literal
+
+from . import attachment
+
+
+@dataclasses.dataclass
+class AttachmentWithContext:
+    """
+    Represents an attachment along with its associated context.
+
+    This class is used to pair an attachment with additional contextual
+    information such as the entity type, entity ID, project name, and
+    context description. It is specifically useful when dealing with
+    attachments related to entities like spans or traces. The context
+    can help provide further insights or classification of the
+    attachment's purpose.
+
+    Attributes:
+        attachment_data: The actual attachment
+            object containing the associated data.
+        entity_type: The type of entity the
+            attachment is associated with. It must be either "span"
+            or "trace".
+        entity_id: The unique identifier of the related entity.
+        project_name: The name of the project to which the
+            attachment and its entity belong.
+        context: A brief context description for the attachment,
+            explaining its purpose or relevance.
+    """
+
+    attachment_data: attachment.Attachment
+    entity_type: Literal["span", "trace"]
+    entity_id: str
+    project_name: str
+    context: str

opik-1.9.54/src/opik/api_objects/attachment/attachments_extractor.py

@@ -0,0 +1,153 @@
+import re
+from typing import Dict, Any, Literal, List, NamedTuple
+
+from . import attachment, attachment_context, decoder_base64
+
+
+class ExtractionResult(NamedTuple):
+    attachments: List[attachment.Attachment]
+    sanitized_data: Any
+
+
+class AttachmentsExtractor:
+    """
+    Extracts and processes attachments embedded as Base64 strings within data structures.
+
+    This class is designed to identify and decode Base64-encoded attachments located
+    within the provided data. It uses a regular expression pattern to search for
+    Base64 strings that meet a specified minimum length. Extracted attachments are
+    decoded and replaced with sanitized placeholders in the original data.
+    """
+
+    def __init__(self, min_attachment_size: int):
+        """
+        Initializes the class with a minimum attachment size and configures the base64
+        pattern for decoding attachments based on its length.
+
+        Args:
+            min_attachment_size: The minimum size of the attachment in characters
+                for it to be considered valid. This ensures that only large enough
+                base64 strings are matched to minimize false positives.
+        """
+        self._min_attachment_size = min_attachment_size
+        self.decoder = decoder_base64.Base64AttachmentDecoder()
+
+        # Pattern to match base64 strings (can be embedded in text)
+        # Requires at least min_attachment_size characters to reduce false positives
+        min_base64_groups = int(min_attachment_size / 4)
+        BASE64_PATTERN = (
+            r"(?:[A-Za-z0-9+/]{4}){"
+            + str(min_base64_groups)
+            + ",}(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"
+        )
+        self.pattern = re.compile(BASE64_PATTERN)
+
+    def extract_and_replace(
+        self,
+        data: Dict[str, Any],
+        entity_type: Literal["span", "trace"],
+        entity_id: str,
+        project_name: str,
+        context: Literal["input", "output", "metadata"],
+    ) -> List[attachment_context.AttachmentWithContext]:
+        # iterate over all items and extract attachments
+        attachments: List[attachment_context.AttachmentWithContext] = []
+        for key, value in data.items():
+            extraction_result = self._try_extract_attachments(value, context)
+            if extraction_result.attachments:
+                # replace the original value with the sanitized one and collect attachments
+                data[key] = extraction_result.sanitized_data
+                for extracted_attachment in extraction_result.attachments:
+                    attachments.append(
+                        attachment_context.AttachmentWithContext(
+                            attachment_data=extracted_attachment,
+                            entity_type=entity_type,
+                            entity_id=entity_id,
+                            project_name=project_name,
+                            context=context,
+                        )
+                    )
+
+        return attachments
+
+    def _try_extract_attachments(
+        self, data: Any, context: Literal["input", "output", "metadata"]
+    ) -> ExtractionResult:
+        """
+        Recursively extract attachments from data that can be a string, dict, list, or other type.
+
+        Args:
+            data: The data to process (can be str, dict, list, or other types)
+            context: The context where the data is located (input, output, or metadata)
+
+        Returns:
+            ExtractionResult with extracted attachments and sanitized data
+        """
+        # Handle string data - check for base64 attachments
+        if isinstance(data, str):
+            return self._extract_from_string(data, context)
+
+        # Handle dictionary data - recursively process each value
+        elif isinstance(data, dict):
+            return self._extract_from_dict(data, context)
+
+        # Handle list data - recursively process each element
+        elif isinstance(data, list):
+            return self._extract_from_list(data, context)
+
+        # For other types (int, bool, None, etc.), return as-is
+        else:
+            return ExtractionResult(attachments=[], sanitized_data=data)
+
+    def _extract_from_string(
+        self, data: str, context: Literal["input", "output", "metadata"]
+    ) -> ExtractionResult:
+        """Extract attachments from a string value."""
+        if len(data) < self._min_attachment_size:
+            # skip short strings
+            return ExtractionResult(attachments=[], sanitized_data=data)
+
+        attachments: List[attachment.Attachment] = []
+        sanitized_data = data
+        for match in self.pattern.finditer(data):
+            to_decode = match.group()
+            decoded_attachment = self.decoder.decode(to_decode, context)
+            if decoded_attachment is not None:
+                attachments.append(decoded_attachment)
+                sanitized_data = sanitized_data.replace(
+                    to_decode, f"[{decoded_attachment.file_name}]"
+                )
+
+        return ExtractionResult(attachments=attachments, sanitized_data=sanitized_data)
+
+    def _extract_from_dict(
+        self, data: Dict[str, Any], context: Literal["input", "output", "metadata"]
+    ) -> ExtractionResult:
+        """Recursively extract attachments from a dictionary."""
+        all_attachments: List[attachment.Attachment] = []
+        sanitized_dict = {}
+
+        for key, value in data.items():
+            result = self._try_extract_attachments(value, context)
+            sanitized_dict[key] = result.sanitized_data
+            all_attachments.extend(result.attachments)
+
+        return ExtractionResult(
+            attachments=all_attachments, sanitized_data=sanitized_dict
+        )
+
+    def _extract_from_list(
+        self, data: List[Any], context: Literal["input", "output", "metadata"]
+    ) -> ExtractionResult:
+        """Recursively extract attachments from a list."""
+        all_attachments: List[attachment.Attachment] = []
+        sanitized_list = []
+
+        for item in data:
+            result = self._try_extract_attachments(item, context)
+            sanitized_list.append(result.sanitized_data)
+            all_attachments.extend(result.attachments)
+
+        return ExtractionResult(
+            attachments=all_attachments, sanitized_data=sanitized_list
+        )

{opik-1.9.38 → opik-1.9.54}/src/opik/api_objects/attachment/client.py

@@ -206,6 +206,7 @@ class AttachmentClient:
             entity_id=entity_id,
             project_name=project_name,
             encoded_url_override=encoded_url_override,
+            delete_after_upload=False,
         )
 
         file_uploader.upload_attachment(

{opik-1.9.38 → opik-1.9.54}/src/opik/api_objects/attachment/converters.py

@@ -13,6 +13,7 @@ def attachment_to_message(
     entity_id: str,
     project_name: str,
     url_override: str,
+    delete_after_upload: bool = False,
 ) -> messages.CreateAttachmentMessage:
     if attachment_data.data is None:
         raise ValueError("Attachment data cannot be None")
@@ -32,6 +33,7 @@ def attachment_to_message(
         entity_id=entity_id,
         project_name=project_name,
         encoded_url_override=base_url_path,
+        delete_after_upload=delete_after_upload,
     )
 
 

opik-1.9.54/src/opik/api_objects/attachment/decoder.py

@@ -0,0 +1,18 @@
+import abc
+from typing import Any, Optional
+
+from . import attachment
+
+
+class AttachmentDecoder(abc.ABC):
+    """
+    Abstract base class for decoding file attachments.
+
+    This class serves as an interface for decoding raw attachment data into
+    an `Attachment` object. Implementing classes should define the specific
+    logic to handle various attachment decoding formats.
+    """
+
+    @abc.abstractmethod
+    def decode(self, raw_data: str, **kwargs: Any) -> Optional[attachment.Attachment]:
+        pass

opik-1.9.54/src/opik/api_objects/attachment/decoder_base64.py

@@ -0,0 +1,83 @@
+import base64
+import binascii
+import logging
+import tempfile
+from typing import Any, Optional, Literal
+
+from . import attachment, decoder, decoder_helpers
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Base64AttachmentDecoder(decoder.AttachmentDecoder):
+    """Decodes base64 encoded attachment data.
+
+    This decoder decodes base64 strings, detects MIME types from content, and creates Attachment objects.
+    """
+
+    def decode(
+        self,
+        raw_data: str,
+        context: Literal["input", "output", "metadata"] = "input",
+        **kwargs: Any,
+    ) -> Optional[attachment.Attachment]:
+        """Decode base64 encoded data into an Attachment object.
+
+        Args:
+            raw_data: Base64 encoded string data
+            context: Context string for filename generation.
+
+        Returns:
+            Attachment object with decoded data, or None if decoding fails or type is not recognizable
+        """
+        if not isinstance(raw_data, str):
+            LOGGER.warning("Attachment data is not a string, skipping.")
+            return None
+
+        try:
+            # Decode base64 string to bytes
+            decoded_bytes = base64.b64decode(raw_data, validate=True)
+
+            # Detect MIME type from content
+            mime_type = decoder_helpers.detect_mime_type(decoded_bytes)
+
+            # Skip if not a recognizable file type
+            if not mime_type or mime_type in ("application/octet-stream", "text/plain"):
+                LOGGER.debug("Attachment type is not recognized, skipping.")
+                return None
+
+            # Get file extension from the MIME type
+            extension = decoder_helpers.get_file_extension(mime_type)
+
+            # Generate filename
+            file_name = decoder_helpers.create_attachment_filename(
+                context, extension=extension
+            )
+
+            # Save decoded bytes to a temporary file
+            temp_file = tempfile.NamedTemporaryFile(
+                mode="wb", delete=False, suffix=extension
+            )
+            temp_file.write(decoded_bytes)
+            temp_file.flush()
+            temp_file.close()
+
+            # Return Attachment object with a file path
+            return attachment.Attachment(
+                data=temp_file.name, file_name=file_name, content_type=mime_type
+            )
+
+        except (ValueError, binascii.Error) as e:
+            LOGGER.debug(
+                "Failed to decode attachment data, reason: invalid base64. Reason: %s",
+                e,
+                exc_info=True,
+            )
+            # Not valid base64, return None
+            return None
+        except Exception as ex:
+            LOGGER.warning(
+                "Failed to decode attachment data, reason: %s", ex, exc_info=True
+            )
+            # Unexpected error, return None to avoid crashing the pipeline
+            return None

opik-1.9.54/src/opik/api_objects/attachment/decoder_helpers.py

@@ -0,0 +1,137 @@
+import mimetypes
+import random
+import time
+from typing import Optional
+
+
+# The attachment file name regex
+ATTACHMENT_FILE_NAME_REGEX = r"(?:input|output|metadata)-attachment-\d+-\d+-sdk\.\w+"
+ATTACHMENT_FILE_NAME_PLACEHOLDER_REGEX = (
+    r"\[((?:input|output|metadata)-attachment-\d+-\d+-sdk\.\w+)\]"
+)
+
+
+def get_file_extension(mime_type: str) -> str:
+    """Convert MIME type to file extension.
+
+    Mirrors the Java getFileExtension() method in AttachmentStripperService.
+
+    Args:
+        mime_type: The MIME type (e.g., "image/png", "application/pdf")
+
+    Returns:
+        File extension without a leading dot (e.g., "png", "pdf")
+    """
+    if not mime_type:
+        return "bin"
+
+    # Try to get extension from mimetypes module
+    extension = mimetypes.guess_extension(mime_type, strict=False)
+
+    if extension:
+        # Remove the leading dot
+        extension = extension.lstrip(".")
+        # Handle special cases where mimetypes returns less common extensions
+        if mime_type == "image/jpeg" and extension == "jpe":
+            return "jpg"
+        return extension
+
+    # Fallback: extract from the MIME type (e.g., "image/png" -> "png")
+    if "/" in mime_type:
+        subtype = mime_type.split("/")[1]
+        # Handle special cases like "svg+xml" -> "svg"
+        if "+" in subtype:
+            subtype = subtype.split("+")[0]
+        # Remove any parameters (e.g., "jpeg; charset=utf-8" -> "jpeg")
+        subtype = subtype.split(";")[0].strip()
+        return subtype
+
+    return "bin"
+
+
+def detect_mime_type(data: bytes) -> Optional[str]:
+    """Detect MIME type from byte content using magic bytes.
+
+    This provides basic MIME type detection similar to Apache Tika in the Java implementation.
+    It checks common file format magic bytes.
+
+    Args:
+        data: The byte data to analyze
+
+    Returns:
+        Detected MIME type string, or "application/octet-stream" if unknown
+    """
+    if len(data) < 4:
+        return "application/octet-stream"
+
+    # Check common file format magic bytes
+    # PNG
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        return "image/png"
+
+    # JPEG
+    if data[:2] == b"\xff\xd8" and data[-2:] == b"\xff\xd9":
+        return "image/jpeg"
+
+    # GIF
+    if data[:6] in (b"GIF87a", b"GIF89a"):
+        return "image/gif"
+
+    # PDF
+    if data[:4] == b"%PDF":
+        return "application/pdf"
+
+    # WebP
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "image/webp"
+
+    # SVG (XML-based, check for SVG tag)
+    try:
+        text = data[:1024].decode("utf-8", errors="ignore")
+        if "<svg" in text.lower():
+            return "image/svg+xml"
+    except Exception:
+        pass
+
+    # MP4
+    if len(data) >= 12 and data[4:8] == b"ftyp":
+        return "video/mp4"
+
+    # JSON
+    try:
+        text = data[:100].decode("utf-8", errors="strict").strip()
+        if text.startswith("{") or text.startswith("["):
+            return "application/json"
+    except Exception:
+        pass
+
+    # Default to octet-stream for unknown types
+    return "application/octet-stream"
+
+
+def create_attachment_filename(context: str, extension: str) -> str:
+    """
+    Generates a unique attachment filename based on the provided context and file extension.
+
+    This function creates a filename by combining the given context, a randomly generated
+    prefix to ensure uniqueness, the current timestamp in milliseconds, and the provided
+    file extension. The generated filename aligns with the backend convention for naming
+    attachments, which includes specific formatting and structure.
+
+    Args:
+        context: The context to use as the base for the filename (e.g., "input",
+            "output", or "metadata").
+        extension: The file extension to use for the filename (e.g., "png",
+            "jpg", "txt").
+
+    Returns:
+        A generated filename string in the format
+            "{context}-attachment-{random_prefix}-{timestamp}.{extension}".
+    """
+    # The backend has the following naming convention: r"\\[((?:input|output|metadata)-attachment-\\d+-\\d+\\.\\w+)\\]"
+    # Example: [input-attachment-1-1704067200000.png]
+
+    timestamp = int(round(time.time() * 1000))
+    # we need to generate a large enough random prefix to avoid collisions
+    random_prefix = random.randint(1, 99999999)
+    return f"{context}-attachment-{random_prefix}-{timestamp}-sdk.{extension}"

{opik-1.9.38 → opik-1.9.54}/src/opik/api_objects/experiment/helpers.py

@@ -1,9 +1,13 @@
+import copy
 import logging
-import opik.jsonable_encoder as jsonable_encoder
 from typing import Any, Dict, List, Mapping, Optional, Tuple
-import copy
+
+from opik import id_helpers
+import opik.jsonable_encoder as jsonable_encoder
+
 from ..prompt import base_prompt
 
+
 LOGGER = logging.getLogger(__name__)
 
 PromptVersion = Dict[str, str]
@@ -74,3 +78,12 @@ def handle_prompt_args(
         prompts = None
 
     return prompts
+
+
+def generate_unique_experiment_name(experiment_name_prefix: Optional[str]) -> str:
+    if experiment_name_prefix is None:
+        return id_helpers.generate_random_alphanumeric_string(12)
+
+    return (
+        f"{experiment_name_prefix}-{id_helpers.generate_random_alphanumeric_string(6)}"
+    )

{opik-1.9.38 → opik-1.9.54}/src/opik/api_objects/local_recording.py

@@ -1,9 +1,10 @@
 import contextlib
 from typing import Iterator, List
 from typing import Optional
+
 from . import opik_client
-from ..message_processing import message_processors_chain
 from ..message_processing.emulation import local_emulator_message_processor, models
+from ..message_processing.processors import message_processors_chain
 
 
 class _LocalRecordingHandle:
@@ -53,7 +54,7 @@ def record_traces_locally(
 
     # Disallow nested/local concurrent recordings in the same process
     existing_local = message_processors_chain.get_local_emulator_message_processor(
-        chain=client._message_processor
+        chain=client.__internal_api__message_processor__
     )
     if existing_local is not None and existing_local.is_active():
         raise RuntimeError(
@@ -61,10 +62,10 @@ def record_traces_locally(
         )
 
     message_processors_chain.toggle_local_emulator_message_processor(
-        active=True, chain=client._message_processor, reset=True
+        active=True, chain=client.__internal_api__message_processor__, reset=True
     )
     local = message_processors_chain.get_local_emulator_message_processor(
-        chain=client._message_processor
+        chain=client.__internal_api__message_processor__
     )
     if local is None:
         # Should not happen given the default chain, but guard just in case
@@ -76,5 +77,5 @@ def record_traces_locally(
     finally:
         client.flush()
         message_processors_chain.toggle_local_emulator_message_processor(
-            active=False, chain=client._message_processor, reset=True
+            active=False, chain=client.__internal_api__message_processor__, reset=True
         )