logfire-api 5.2.0__tar.gz → 5.4.0__tar.gz

{logfire_api-5.2.0 → logfire_api-5.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 5.2.0
+Version: 5.4.0
 Summary: Shim for the Logfire SDK which does nothing unless Logfire is installed
 Author-email: Pydantic Team <engineering@pydantic.dev>, Samuel Colvin <samuel@pydantic.dev>, Hasan Ramezani <hasan@pydantic.dev>, Adrian Garcia Badaracco <adrian@pydantic.dev>, David Montague <david@pydantic.dev>, Marcelo Trylesinski <marcelo@pydantic.dev>, David Hewitt <david.hewitt@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/__init__.py

@@ -155,6 +155,11 @@ except ImportError:
 
             def instrument_monty(self, *args, **kwargs) -> None: ...
 
+            def agent_sandboxes(self, *args, **kwargs) -> Any:
+                raise RuntimeError(
+                    "`logfire.agent_sandboxes()` requires the `logfire` package, install it with `pip install 'logfire[agent-sandboxes]'`"
+                )
+
             def instrument_pymongo(self, *args, **kwargs) -> None: ...
 
             def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
@@ -247,6 +252,7 @@ except ImportError:
         instrument_pydantic = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic
         instrument_pydantic_ai = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic_ai
         instrument_monty = DEFAULT_LOGFIRE_INSTANCE.instrument_monty
+        agent_sandboxes = DEFAULT_LOGFIRE_INSTANCE.agent_sandboxes
         instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
         instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
         instrument_openai_agents = DEFAULT_LOGFIRE_INSTANCE.instrument_openai_agents

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/__init__.pyi

@@ -16,7 +16,7 @@ from logfire.propagate import attach_context as attach_context, get_context as g
 from logfire.sampling import SamplingOptions as SamplingOptions
 from typing import Any
 
-__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'AdvancedOptions', 'ConsoleOptions', 'CodeSource', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'warning', 'error', 'exception', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_asgi', 'instrument_wsgi', 'instrument_pydantic', 'instrument_pydantic_ai', 'instrument_monty', 'instrument_fastapi', 'instrument_openai', 'instrument_openai_agents', 'instrument_anthropic', 'instrument_google_genai', 'instrument_litellm', 'instrument_dspy', 'instrument_print', 'instrument_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_litestar', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_surrealdb', 'instrument_snowflake', 'instrument_system_metrics', 'instrument_mcp', 'instrument_claude_agent_sdk', 'AutoTraceModule', 'with_tags', 'with_settings', 'suppress_scopes', 'shutdown', 'no_auto_trace', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'add_non_user_code_prefix', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'loguru_handler', 'SamplingOptions', 'MetricsOptions', 'VariablesOptions', 'LocalVariablesOptions', 'variables', 'var', 'template_var', 'variables_get', 'variables_push', 'variables_push_types', 'variables_validate', 'variables_push_config', 'variables_pull_config', 'variables_build_config', 'logfire_info', 'get_baggage', 'set_baggage', 'get_context', 'attach_context', 'url_from_eval', 'forward_export_request', 'forward_export_request_starlette']
+__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'AdvancedOptions', 'ConsoleOptions', 'CodeSource', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'warning', 'error', 'exception', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_asgi', 'instrument_wsgi', 'instrument_pydantic', 'instrument_pydantic_ai', 'instrument_monty', 'agent_sandboxes', 'instrument_fastapi', 'instrument_openai', 'instrument_openai_agents', 'instrument_anthropic', 'instrument_google_genai', 'instrument_litellm', 'instrument_dspy', 'instrument_print', 'instrument_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_litestar', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_surrealdb', 'instrument_snowflake', 'instrument_system_metrics', 'instrument_mcp', 'instrument_claude_agent_sdk', 'AutoTraceModule', 'with_tags', 'with_settings', 'suppress_scopes', 'shutdown', 'no_auto_trace', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'add_non_user_code_prefix', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'loguru_handler', 'SamplingOptions', 'MetricsOptions', 'VariablesOptions', 'LocalVariablesOptions', 'variables', 'var', 'template_var', 'variables_get', 'variables_push', 'variables_push_types', 'variables_validate', 'variables_push_config', 'variables_pull_config', 'variables_build_config', 'logfire_info', 'get_baggage', 'set_baggage', 'get_context', 'attach_context', 'url_from_eval', 'forward_export_request', 'forward_export_request_starlette']
 
 DEFAULT_LOGFIRE_INSTANCE = Logfire()
 span = DEFAULT_LOGFIRE_INSTANCE.span
@@ -27,6 +27,7 @@ install_auto_tracing = DEFAULT_LOGFIRE_INSTANCE.install_auto_tracing
 instrument_pydantic = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic
 instrument_pydantic_ai = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic_ai
 instrument_monty = DEFAULT_LOGFIRE_INSTANCE.instrument_monty
+agent_sandboxes = DEFAULT_LOGFIRE_INSTANCE.agent_sandboxes
 instrument_asgi = DEFAULT_LOGFIRE_INSTANCE.instrument_asgi
 instrument_wsgi = DEFAULT_LOGFIRE_INSTANCE.instrument_wsgi
 instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi

logfire_api-5.4.0/logfire_api/_internal/agent_sandboxes.pyi

@@ -0,0 +1,10 @@
+from collections.abc import Callable, Mapping as Mapping
+from logfire import Logfire as Logfire
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from logfire.propagate import get_context as get_context
+from pydantic_monty import AsyncMontyWebsocket
+from typing import Any
+
+def agent_sandboxes_url(base_url: str) -> str:
+    """Convert a Logfire HTTP(S) base URL into the agent sandboxes WebSocket URL."""
+def create_agent_sandboxes(logfire_instance: Logfire, *, api_key: str | None, url: str | None, connect_headers: Callable[[], Mapping[str, str]] | None = None, **kwargs: Any) -> AsyncMontyWebsocket: ...

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/cli/auth.pyi

@@ -10,4 +10,8 @@ def parse_auth(args: argparse.Namespace) -> None:
     This will authenticate your machine with Logfire and store the credentials.
     """
 def parse_logout(args: argparse.Namespace) -> None:
-    """Log out from Logfire."""
+    """Log out from Logfire.
+
+    Remove stored user tokens for --region, --base-url, or a non-empty LOGFIRE_BASE_URL.
+    With no target configured, remove all stored user tokens.
+    """

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/config.pyi

@@ -45,6 +45,7 @@ from opentelemetry.sdk.metrics.export import MetricReader as MetricReader
 from opentelemetry.sdk.metrics.view import View
 from opentelemetry.sdk.resources import ResourceDetector
 from opentelemetry.sdk.trace import SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter as SpanExporter
 from opentelemetry.sdk.trace.id_generator import IdGenerator
 from pathlib import Path
 from typing import Any, ClassVar, Literal, TextIO
@@ -80,6 +81,7 @@ class AdvancedOptions:
     server_response_hook: ServerResponseCallback | None = ...
     resource_detectors: Sequence[ResourceDetector | str] | None = ...
     compression: CompressionValues | None = ...
+    pending_spans: bool | None = ...
     def generate_base_url(self, token: str, warn_unknown_region: bool = True) -> str:
         """Resolve the base API URL for `token`, honouring an explicitly configured `base_url`.
 

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/config_params.pyi

@@ -58,6 +58,7 @@ IGNORE_NO_CONFIG: Incomplete
 BASE_URL: Incomplete
 DISTRIBUTED_TRACING: Incomplete
 EMIT_CONFIGURATION_SPAN: Incomplete
+PENDING_SPANS: Incomplete
 COMPRESSION: Incomplete
 HTTPX_CAPTURE_ALL: Incomplete
 AIOHTTP_CLIENT_CAPTURE_ALL: Incomplete

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/db_statement_summary.pyi

@@ -26,6 +26,11 @@ def summarize_query(db_statement: str) -> str | None:
 
     """
 def select(expr: str, table: str, *, match_end: int, db_statement: str, ctes: str | None = None, sub_query: str | None = None) -> str: ...
+def outside_parentheses(s: str) -> str:
+    """Remove everything inside parentheses, including the parentheses themselves.
+
+    Parentheses inside quoted strings or identifiers don't change the nesting depth.
+    """
 def truncate(s: str, length: int) -> str: ...
 
 FALLBACK_HALF: Incomplete

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/formatter.pyi

@@ -28,7 +28,7 @@ class ChunksFormatter(Formatter):
 chunks_formatter: Incomplete
 
 def logfire_format(format_string: str, kwargs: dict[str, Any], scrubber: BaseScrubber) -> str: ...
-def logfire_format_with_magic(format_string: str, kwargs: dict[str, Any], scrubber: BaseScrubber, fstring_frame: types.FrameType | None = None) -> tuple[str, dict[str, Any], str]: ...
+def logfire_format_with_magic(format_string: Any, kwargs: dict[str, Any], scrubber: BaseScrubber, fstring_frame: types.FrameType | None = None) -> tuple[str, dict[str, Any], str]: ...
 @lru_cache
 def compile_formatted_value(node: ast.FormattedValue, ex_source: executing.Source) -> tuple[str, CodeType, CodeType]:
     """Returns three things that can be expensive to compute.

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/integrations/claude_agent_sdk.pyi

@@ -2,7 +2,7 @@ from _typeshed import Incomplete
 from claude_agent_sdk import AssistantMessage
 from claude_agent_sdk.types import HookContext, SyncHookJSONOutput
 from contextlib import AbstractContextManager
-from logfire._internal.integrations.llm_providers.semconv import CONVERSATION_ID as CONVERSATION_ID, ChatMessage as ChatMessage, ERROR_TYPE as ERROR_TYPE, INPUT_MESSAGES as INPUT_MESSAGES, MessagePart as MessagePart, OPERATION_NAME as OPERATION_NAME, OUTPUT_MESSAGES as OUTPUT_MESSAGES, OutputMessage as OutputMessage, PROVIDER_NAME as PROVIDER_NAME, REQUEST_MODEL as REQUEST_MODEL, RESPONSE_MODEL as RESPONSE_MODEL, ReasoningPart as ReasoningPart, SYSTEM as SYSTEM, SYSTEM_INSTRUCTIONS as SYSTEM_INSTRUCTIONS, TOOL_CALL_ARGUMENTS as TOOL_CALL_ARGUMENTS, TOOL_CALL_ID as TOOL_CALL_ID, TOOL_CALL_RESULT as TOOL_CALL_RESULT, TOOL_NAME as TOOL_NAME, TextPart as TextPart, ToolCallPart as ToolCallPart, ToolCallResponsePart as ToolCallResponsePart
+from logfire._internal.integrations.llm_providers.semconv import CONVERSATION_ID as CONVERSATION_ID, ChatMessage as ChatMessage, ERROR_TYPE as ERROR_TYPE, INPUT_MESSAGES as INPUT_MESSAGES, MessagePart as MessagePart, OPERATION_NAME as OPERATION_NAME, OUTPUT_MESSAGES as OUTPUT_MESSAGES, OutputMessage as OutputMessage, PROVIDER_NAME as PROVIDER_NAME, REQUEST_MODEL as REQUEST_MODEL, RESPONSE_FINISH_REASONS as RESPONSE_FINISH_REASONS, RESPONSE_ID as RESPONSE_ID, RESPONSE_MODEL as RESPONSE_MODEL, ReasoningPart as ReasoningPart, SYSTEM as SYSTEM, SYSTEM_INSTRUCTIONS as SYSTEM_INSTRUCTIONS, TOOL_CALL_ARGUMENTS as TOOL_CALL_ARGUMENTS, TOOL_CALL_ID as TOOL_CALL_ID, TOOL_CALL_RESULT as TOOL_CALL_RESULT, TOOL_NAME as TOOL_NAME, TextPart as TextPart, ToolCallPart as ToolCallPart, ToolCallResponsePart as ToolCallResponsePart
 from logfire._internal.main import Logfire as Logfire, LogfireSpan as LogfireSpan
 from logfire._internal.stack_info import get_user_stack_info as get_user_stack_info
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
@@ -63,5 +63,11 @@ class _ConversationState:
         """Handle UserMessage: open a new chat span for the next LLM call."""
     def handle_assistant_message(self, message: AssistantMessage) -> None:
         """Handle AssistantMessage: add output and usage to the current chat span."""
+    def set_finish_reason(self, stop_reason: str | None) -> None:
+        """Record the stop reason on the current chat span.
+
+        The CLI streams assistant messages with a null `stop_reason`;
+        the final one is only reported on the ResultMessage.
+        """
     def close(self) -> None:
         """Close chat span and end any orphaned tool spans."""

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/integrations/fastapi.pyi

@@ -1,3 +1,4 @@
+import dataclasses
 from ..constants import ONE_SECOND_IN_NANOSECONDS as ONE_SECOND_IN_NANOSECONDS
 from ..main import Logfire as Logfire, NoopSpan as NoopSpan, set_user_attributes_on_raw_span as set_user_attributes_on_raw_span
 from ..stack_info import StackInfo as StackInfo, get_code_object_info as get_code_object_info
@@ -8,21 +9,43 @@ from collections.abc import Awaitable, Callable, Iterable
 from contextlib import AbstractContextManager, contextmanager
 from fastapi import FastAPI
 from functools import lru_cache
+from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware
 from opentelemetry.trace import Span
 from starlette.requests import Request
+from starlette.types import Receive, Scope, Send
 from starlette.websockets import WebSocket
 from typing import Any
+from weakref import WeakKeyDictionary
 
 def find_mounted_apps(app: FastAPI) -> list[FastAPI]:
     """Fetch all sub-apps mounted to a FastAPI app, including nested sub-apps."""
-def instrument_fastapi(logfire_instance: Logfire, app: FastAPI, *, capture_headers: bool = False, request_attributes_mapper: Callable[[Request | WebSocket, dict[str, Any]], dict[str, Any] | None] | None = None, excluded_urls: str | Iterable[str] | None = None, record_send_receive: bool = False, extra_spans: bool = False, **opentelemetry_kwargs: Any) -> AbstractContextManager[None]:
+def instrument_fastapi(logfire_instance: Logfire, app: FastAPI | None = None, *, capture_headers: bool = False, request_attributes_mapper: Callable[[Request | WebSocket, dict[str, Any]], dict[str, Any] | None] | None = None, excluded_urls: str | Iterable[str] | None = None, record_send_receive: bool = False, extra_spans: bool = False, **opentelemetry_kwargs: Any) -> AbstractContextManager[None]:
     """Instrument a FastAPI app so that spans and logs are automatically created for each request.
 
     See `Logfire.instrument_fastapi` for more details.
     """
+
+class OncePerRequest:
+    """Run only the outermost FastAPI OpenTelemetry middleware for each ASGI request.
+
+    This way mounted apps don't start duplicate spans for the same request,
+    and they don't trace requests that were excluded by their outer app.
+    """
+    app: Incomplete
+    def __init__(self, app: OpenTelemetryMiddleware) -> None: ...
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: ...
+
+@dataclasses.dataclass
+class _FastAPIRegistry:
+    """Track Logfire instrumentation settings for FastAPI apps."""
+    global_instrumentation: FastAPIInstrumentation | None = ...
+    per_app: WeakKeyDictionary[FastAPI, FastAPIInstrumentation] = dataclasses.field(default_factory=Incomplete)
+    def get_instrumentation(self, app: FastAPI) -> FastAPIInstrumentation | None:
+        """Get the instrumentation for a specific app, or the global instrumentation if none is set."""
+
 @lru_cache
-def patch_fastapi():
-    """Globally monkeypatch fastapi functions and return a dictionary for recording instrumentation config per app."""
+def patch_fastapi() -> _FastAPIRegistry:
+    """Globally monkeypatch fastapi functions and return their instrumentation registry."""
 
 class FastAPIInstrumentation:
     logfire_instance: Incomplete

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/integrations/flask.pyi

@@ -1,9 +1,10 @@
 from flask.app import Flask
+from logfire import Logfire as Logfire
 from logfire._internal.utils import maybe_capture_server_headers as maybe_capture_server_headers
 from logfire.integrations.flask import CommenterOptions as CommenterOptions, RequestHook as RequestHook, ResponseHook as ResponseHook
 from typing import Any
 
-def instrument_flask(app: Flask, *, capture_headers: bool, enable_commenter: bool, commenter_options: CommenterOptions | None, excluded_urls: str | None = None, request_hook: RequestHook | None = None, response_hook: ResponseHook | None = None, **kwargs: Any):
+def instrument_flask(logfire_instance: Logfire, app: Flask | None = None, *, capture_headers: bool = False, enable_commenter: bool = True, commenter_options: CommenterOptions | None = None, excluded_urls: str | None = None, request_hook: RequestHook | None = None, response_hook: ResponseHook | None = None, **kwargs: Any) -> None:
     """Instrument `app` so that spans are automatically created for each request.
 
     See the `Logfire.instrument_flask` method for details.

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/integrations/openai_agents.pyi

@@ -7,7 +7,8 @@ from agents.tracing.spans import SpanError, TSpanData
 from dataclasses import dataclass
 from logfire import Logfire as Logfire, LogfireSpan as LogfireSpan
 from logfire._internal.formatter import logfire_format as logfire_format
-from logfire._internal.integrations.llm_providers.openai import get_openai_usage_attributes as get_openai_usage_attributes, inputs_to_events as inputs_to_events, responses_output_events as responses_output_events
+from logfire._internal.integrations.llm_providers.openai import get_openai_usage_attributes as get_openai_usage_attributes, inputs_to_events as inputs_to_events, responses_finish_reasons as responses_finish_reasons, responses_output_events as responses_output_events
+from logfire._internal.integrations.llm_providers.semconv import RESPONSE_FINISH_REASONS as RESPONSE_FINISH_REASONS, RESPONSE_ID as RESPONSE_ID
 from logfire._internal.scrubbing import NOOP_SCRUBBER as NOOP_SCRUBBER
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors, log_internal_error as log_internal_error, truncate_string as truncate_string
 from openai.types.responses import Response

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/integrations/starlette.pyi

@@ -5,7 +5,7 @@ from opentelemetry.instrumentation.asgi.types import ClientRequestHook, ClientRe
 from starlette.applications import Starlette
 from typing import Any
 
-def instrument_starlette(logfire_instance: Logfire, app: Starlette, *, record_send_receive: bool = False, capture_headers: bool = False, server_request_hook: ServerRequestHook | None = None, client_request_hook: ClientRequestHook | None = None, client_response_hook: ClientResponseHook | None = None, **kwargs: Any):
+def instrument_starlette(logfire_instance: Logfire, app: Starlette | None = None, *, record_send_receive: bool = False, capture_headers: bool = False, server_request_hook: ServerRequestHook | None = None, client_request_hook: ClientRequestHook | None = None, client_response_hook: ClientResponseHook | None = None, **kwargs: Any) -> None:
     """Instrument `app` so that spans are automatically created for each request.
 
     See the `Logfire.instrument_starlette` method for details.

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/json_encoder.pyi

@@ -4,6 +4,10 @@ from functools import cache, lru_cache
 from typing import Any
 
 NUMPY_DIMENSION_MAX_SIZE: int
+
+def pandas_display_slices(count: int, limit: int | None) -> tuple[slice, ...]:
+    """Return the first and last positions selected by a pandas display limit."""
+
 EncoderFunction: Incomplete
 
 @cache

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/main.pyi

@@ -40,6 +40,7 @@ from anthropic.lib.bedrock import AnthropicBedrock as _AnthropicBedrock, AsyncAn
 from collections.abc import Iterable, Mapping, Sequence
 from contextlib import AbstractContextManager
 from django.http import HttpRequest as HttpRequest, HttpResponse as HttpResponse
+from enum import Enum
 from fastapi import FastAPI
 from flask.app import Flask
 from litestar import Litestar
@@ -50,6 +51,7 @@ from opentelemetry.sdk.trace import ReadableSpan, Span
 from opentelemetry.trace import SpanContext, SpanKind
 from opentelemetry.util import types as otel_types
 from pydantic_evals.reporting import EvaluationReport
+from pydantic_monty import AsyncMontyWebsocket
 from pymongo.monitoring import CommandFailedEvent as CommandFailedEvent, CommandStartedEvent as CommandStartedEvent, CommandSucceededEvent as CommandSucceededEvent
 from snowflake.connector.connection import SnowflakeConnection
 from sqlalchemy import Engine
@@ -69,6 +71,9 @@ ExcInfo = SysExcInfo | BaseException | bool | None
 T = TypeVar('T')
 InputsT = TypeVar('InputsT')
 
+class _Unset(Enum):
+    UNSET: str
+
 class Logfire:
     """The main logfire class."""
     def __init__(self, *, config: LogfireConfig = ..., sample_rate: float | None = None, tags: Sequence[str] = (), console_log: bool = True, otel_scope: str = 'logfire') -> None: ...
@@ -244,7 +249,8 @@ class Logfire:
         ```
 
         Args:
-            msg_template: The template for the span message.
+            msg_template: A string template for the span message. Passing another type emits a formatting
+                warning and uses its `str()` representation without interpolating it.
             _span_name: The span name. If not provided, the `msg_template` will be used.
             _tags: An optional sequence of tags to include in the span.
             _level: An optional log level name.
@@ -313,7 +319,8 @@ class Logfire:
 
         Args:
             level: The level of the log.
-            msg_template: The message to log.
+            msg_template: A string message or template. Passing another type emits a formatting warning
+                and uses its `str()` representation without interpolating it.
             attributes: The attributes to bind to the log.
             tags: An optional sequence of tags to include in the log.
             exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info]
@@ -520,6 +527,57 @@ class Logfire:
         It records Monty sessions, executed code, inputs, outputs, external calls,
         exceptions, printed text, and pool metrics. Recorded values are subject to Logfire's configured scrubbing.
         """
+    def agent_sandboxes(self, *, api_key: str | None = None, url: str | None = None, max_processes: int | None | _Unset = ..., checkout_timeout: float | None | _Unset = ..., request_timeout: float | None | _Unset = ..., connect_headers: Callable[[], Mapping[str, str]] | None | _Unset = ..., feed_duration_limit_grace: float | None | _Unset = ..., turn_duration_limit_grace: float | None | _Unset = ..., auto_resume: bool | _Unset = ..., **kwargs: Any) -> AsyncMontyWebsocket:
+        """Connect to Logfire Agent Sandboxes, remote Pydantic Monty workers hosted by Logfire.
+
+        Requires the `agent-sandboxes` extra, e.g. `pip install 'logfire[agent-sandboxes]'`.
+
+        Returns a [`pydantic_monty.AsyncMontyWebsocket`][pydantic_monty.AsyncMontyWebsocket] pool;
+        use it as an async context manager and check out sessions from it:
+
+        ```py
+        import logfire
+
+        logfire.configure()
+
+
+        async def main():
+            async with logfire.agent_sandboxes() as pool:
+                async with pool.checkout() as session:
+                    result = await session.feed_run('1 + 1')
+        ```
+
+        No connection is made until a session is checked out.
+
+        The Logfire platform records sandbox usage itself. The current trace context is sent
+        with each session so those spans join the caller's trace.
+
+        Omitted pool options use the defaults of the installed `pydantic-monty-client` version.
+        The defaults described below are the currently assumed defaults and may change in future versions.
+
+        Args:
+            api_key: A Logfire API key with the `project:execute_agent_sandboxes` scope.
+                Defaults to the `api_key` passed to [`configure()`][logfire.configure],
+                then the `LOGFIRE_API_KEY` environment variable.
+            url: The WebSocket URL of the sandboxes server.
+                Defaults to the Logfire region the API key belongs to.
+            max_processes: Cap on concurrent sandbox connections. Defaults to `None`, which uses
+                the CPU count; checkouts beyond it wait.
+            checkout_timeout: Seconds `checkout()` waits for capacity before raising `TimeoutError`.
+                Defaults to `None`, which waits forever.
+            request_timeout: Hard per-turn deadline in seconds. A sandbox that exceeds it has its
+                connection closed and the call raises `MontyCrashedError`. `None` waits indefinitely.
+                Defaults to `10.0`. Raise this when installing dependencies in a sandbox.
+            connect_headers: Called once per session to produce extra headers for the WebSocket
+                connection. These are merged with the `Authorization` header and win on conflicts.
+                Defaults to `None`, which adds no extra headers beyond Logfire authentication.
+            feed_duration_limit_grace: Seconds to wait past a feed's `max_feed_duration_secs`
+                before closing the sandbox. Defaults to `1.0`; `None` disables this backstop.
+            turn_duration_limit_grace: The same, for `max_turn_duration_secs`. Defaults to `1.0`.
+            auto_resume: When the server drains a stored session, transparently resume it on
+                another server instead of raising `MontyShutdown`. Defaults to `True`.
+            kwargs: Additional keyword arguments passed to `AsyncMontyWebsocket` for future compatibility.
+        """
     def instrument_fastapi(self, app: FastAPI, *, capture_headers: bool = False, request_attributes_mapper: Callable[[Request | WebSocket, dict[str, Any]], dict[str, Any] | None] | None = None, excluded_urls: str | Iterable[str] | None = None, record_send_receive: bool = False, extra_spans: bool = False, **opentelemetry_kwargs: Any) -> AbstractContextManager[None]:
         """Instrument a FastAPI app so that spans and logs are automatically created for each request.
 
@@ -590,7 +648,7 @@ class Logfire:
         logfire.instrument_openai(client)
 
         response = client.chat.completions.create(
-            model=\'gpt-4\',
+            model=\'gpt-5-mini\',
             messages=[
                 {\'role\': \'system\', \'content\': \'You are a helpful assistant.\'},
                 {\'role\': \'user\', \'content\': \'What is four plus five?\'},
@@ -641,7 +699,7 @@ class Logfire:
 
         - [`client.messages.create`](https://docs.anthropic.com/en/api/messages)
         - [`client.messages.stream`](https://docs.anthropic.com/en/api/messages-streaming)
-        - [`client.beta.tools.messages.create`](https://docs.anthropic.com/en/docs/tool-use)
+        - [`client.beta.messages.create`](https://docs.anthropic.com/en/docs/tool-use)
 
         When `stream=True` a second span is created to instrument the streamed response.
 
@@ -658,7 +716,7 @@ class Logfire:
         logfire.instrument_anthropic(client)
 
         response = client.messages.create(
-            model=\'claude-3-haiku-20240307\',
+            model=\'claude-haiku-5-5\',
             system=\'You are a helpful assistant.\',
             messages=[
                 {\'role\': \'user\', \'content\': \'What is four plus five?\'},
@@ -938,6 +996,10 @@ class Logfire:
         [OpenTelemetry SQLAlchemy Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/sqlalchemy/sqlalchemy.html)
         library, specifically `SQLAlchemyInstrumentor().instrument()`, to which it passes `**kwargs`.
 
+        If the installed SQLAlchemy version is outside the range that instrumentation supports, this raises
+        `RuntimeError` instead of returning without recording queries.
+        Pass `skip_dep_check=True` to bypass this check. That may produce no spans or errors if the version really is incompatible.
+
         Args:
             engine: The `sqlalchemy` engine to instrument.
             engines: An iterable of `sqlalchemy` engines to instrument.

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/tracer.pyi

@@ -2,7 +2,7 @@ import opentelemetry.trace as trace_api
 from ..types import ExceptionCallback as ExceptionCallback
 from .config import LogfireConfig as LogfireConfig
 from .constants import ATTRIBUTES_EXCEPTION_FINGERPRINT_KEY as ATTRIBUTES_EXCEPTION_FINGERPRINT_KEY, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY as ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_VALIDATION_ERROR_KEY as ATTRIBUTES_VALIDATION_ERROR_KEY, log_level_attributes as log_level_attributes
-from .utils import handle_internal_errors as handle_internal_errors, sha256_string as sha256_string
+from .utils import handle_internal_errors as handle_internal_errors, is_instrumentation_suppressed as is_instrumentation_suppressed, safe_str as safe_str, safe_type_name as safe_type_name, sha256_string as sha256_string
 from _typeshed import Incomplete
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/_internal/utils.pyi

@@ -32,6 +32,19 @@ def uniquify_sequence(seq: Sequence[T]) -> tuple[T, ...]:
     """Remove duplicates from a sequence preserving order."""
 def safe_repr(obj: Any) -> str:
     """Return some kind of non-empty string representation of an object, catching exceptions."""
+def safe_str(obj: Any) -> str:
+    """Return `str(obj)`, or a placeholder if calling `str()` itself raises.
+
+    Some objects (notably exceptions that were never fully initialised) raise from `__str__`.
+    Callers on the telemetry path must never let that abort their own work, so the placeholder
+    deliberately avoids looking anything up on the object or its class.
+    """
+def safe_type_name(obj: Any) -> str:
+    """Return the bare class name of `obj`, or a placeholder if that lookup raises.
+
+    A metaclass can turn `__name__` into a property that raises, so even reading the class
+    name is not safe on the telemetry path.
+    """
 Truncatable = TypeVar('Truncatable', str, bytes, 'list[Any]', 'tuple[Any, ...]')
 
 def truncate_string(s: str, *, max_length: int, middle: str = '...') -> str:

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/integrations/logging.pyi

@@ -1,5 +1,5 @@
 from .. import Logfire as Logfire
-from .._internal.constants import ATTRIBUTES_LOGGING_ARGS_KEY as ATTRIBUTES_LOGGING_ARGS_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, LOGGING_TO_OTEL_LEVEL_NUMBERS as LOGGING_TO_OTEL_LEVEL_NUMBERS
+from .._internal.constants import ATTRIBUTES_LOGGING_ARGS_KEY as ATTRIBUTES_LOGGING_ARGS_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, LOGGING_TO_OTEL_LEVEL_NUMBERS as LOGGING_TO_OTEL_LEVEL_NUMBERS
 from .._internal.utils import is_instrumentation_suppressed as is_instrumentation_suppressed
 from _typeshed import Incomplete
 from collections.abc import Mapping as Mapping

{logfire_api-5.2.0 → logfire_api-5.4.0}/logfire_api/integrations/structlog.pyi

@@ -1,5 +1,5 @@
 from .. import Logfire as Logfire
-from .._internal.constants import ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY
+from .._internal.constants import ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY
 from _typeshed import Incomplete
 from structlog.types import EventDict, WrappedLogger
 

{logfire_api-5.2.0 → logfire_api-5.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "logfire-api"
-version = "5.2.0"
+version = "5.4.0"
 description = "Shim for the Logfire SDK which does nothing unless Logfire is installed"
 authors = [
     { name = "Pydantic Team", email = "engineering@pydantic.dev" },