logfire-api 5.1.1__tar.gz → 5.3.0__tar.gz

{logfire_api-5.1.1 → logfire_api-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 5.1.1
+Version: 5.3.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.1.1 → logfire_api-5.3.0}/logfire_api/__init__.py

@@ -153,6 +153,8 @@ except ImportError:
 
             def instrument_pydantic_ai(self, *args, **kwargs) -> None: ...
 
+            def instrument_monty(self, *args, **kwargs) -> None: ...
+
             def instrument_pymongo(self, *args, **kwargs) -> None: ...
 
             def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
@@ -176,6 +178,8 @@ except ImportError:
 
             def instrument_surrealdb(self, *args, **kwargs) -> None: ...
 
+            def instrument_snowflake(self, *args, **kwargs) -> None: ...
+
             def instrument_requests(self, *args, **kwargs) -> None: ...
 
             def instrument_httpx(self, *args, **kwargs) -> None: ...
@@ -242,6 +246,7 @@ except ImportError:
         instrument_wsgi = DEFAULT_LOGFIRE_INSTANCE.instrument_wsgi
         instrument_pydantic = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic
         instrument_pydantic_ai = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic_ai
+        instrument_monty = DEFAULT_LOGFIRE_INSTANCE.instrument_monty
         instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
         instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
         instrument_openai_agents = DEFAULT_LOGFIRE_INSTANCE.instrument_openai_agents
@@ -255,6 +260,7 @@ except ImportError:
         instrument_httpx = DEFAULT_LOGFIRE_INSTANCE.instrument_httpx
         instrument_requests = DEFAULT_LOGFIRE_INSTANCE.instrument_requests
         instrument_surrealdb = DEFAULT_LOGFIRE_INSTANCE.instrument_surrealdb
+        instrument_snowflake = DEFAULT_LOGFIRE_INSTANCE.instrument_snowflake
         instrument_psycopg = DEFAULT_LOGFIRE_INSTANCE.instrument_psycopg
         instrument_django = DEFAULT_LOGFIRE_INSTANCE.instrument_django
         instrument_flask = DEFAULT_LOGFIRE_INSTANCE.instrument_flask

{logfire_api-5.1.1 → logfire_api-5.3.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_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_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', '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
@@ -26,6 +26,7 @@ log_slow_async_callbacks = DEFAULT_LOGFIRE_INSTANCE.log_slow_async_callbacks
 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
 instrument_asgi = DEFAULT_LOGFIRE_INSTANCE.instrument_asgi
 instrument_wsgi = DEFAULT_LOGFIRE_INSTANCE.instrument_wsgi
 instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
@@ -54,6 +55,7 @@ instrument_redis = DEFAULT_LOGFIRE_INSTANCE.instrument_redis
 instrument_pymongo = DEFAULT_LOGFIRE_INSTANCE.instrument_pymongo
 instrument_mysql = DEFAULT_LOGFIRE_INSTANCE.instrument_mysql
 instrument_surrealdb = DEFAULT_LOGFIRE_INSTANCE.instrument_surrealdb
+instrument_snowflake = DEFAULT_LOGFIRE_INSTANCE.instrument_snowflake
 instrument_system_metrics = DEFAULT_LOGFIRE_INSTANCE.instrument_system_metrics
 instrument_mcp = DEFAULT_LOGFIRE_INSTANCE.instrument_mcp
 instrument_claude_agent_sdk = DEFAULT_LOGFIRE_INSTANCE.instrument_claude_agent_sdk

{logfire_api-5.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.0}/logfire_api/_internal/cli/run.pyi

@@ -1,6 +1,6 @@
 import argparse
 from _typeshed import Incomplete
-from collections.abc import Collection, Generator, Mapping
+from collections.abc import Callable, Collection, Generator, Mapping
 from contextlib import contextmanager
 from dataclasses import dataclass
 from logfire._internal.utils import get_version as get_version
@@ -34,6 +34,13 @@ class InstrumentationContext:
     recommendations: set[InstrumentationRecommendation]
 
 def parse_run(args: argparse.Namespace) -> None: ...
+def load_console_entry_point(name: str) -> Callable[[], object] | None:
+    """Load one installed `console_scripts` entry point before local modules can shadow it."""
+@contextmanager
+def without_working_directory_on_sys_path() -> Generator[None, None, None]:
+    """Temporarily give entry-point imports the path behavior of an installed launcher."""
+def run_console_entry_point(entry_point: Callable[[], object], argv: list[str]) -> None:
+    """Run a loaded console entry point with the target command's arguments."""
 @contextmanager
 def alter_sys_argv(argv: list[str], cmd: str) -> Generator[None, None, None]: ...
 def is_uv_installed() -> bool:

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/_internal/config.pyi

@@ -4,12 +4,12 @@ import requests
 from ..propagate import NoExtractTraceContextPropagator as NoExtractTraceContextPropagator, WarnOnExtractTraceContextPropagator as WarnOnExtractTraceContextPropagator
 from ..types import ExceptionCallback as ExceptionCallback
 from .client import InvalidProjectName as InvalidProjectName, LogfireClient as LogfireClient, ProjectAlreadyExists as ProjectAlreadyExists
-from .config_params import ParamManager as ParamManager, PydanticPluginRecordValues as PydanticPluginRecordValues, normalize_token as normalize_token
+from .config_params import CompressionValues as CompressionValues, ParamManager as ParamManager, PydanticPluginRecordValues as PydanticPluginRecordValues, normalize_token as normalize_token
 from .constants import ATTRIBUTES_CONFIG as ATTRIBUTES_CONFIG, ATTRIBUTES_PACKAGE_VERSIONS as ATTRIBUTES_PACKAGE_VERSIONS, LEVEL_NUMBERS as LEVEL_NUMBERS, LevelName as LevelName, RESOURCE_ATTRIBUTES_CODE_ROOT_PATH as RESOURCE_ATTRIBUTES_CODE_ROOT_PATH, RESOURCE_ATTRIBUTES_CODE_WORK_DIR as RESOURCE_ATTRIBUTES_CODE_WORK_DIR, RESOURCE_ATTRIBUTES_DEPLOYMENT_ENVIRONMENT_NAME as RESOURCE_ATTRIBUTES_DEPLOYMENT_ENVIRONMENT_NAME, RESOURCE_ATTRIBUTES_VCS_REPOSITORY_REF_REVISION as RESOURCE_ATTRIBUTES_VCS_REPOSITORY_REF_REVISION, RESOURCE_ATTRIBUTES_VCS_REPOSITORY_URL as RESOURCE_ATTRIBUTES_VCS_REPOSITORY_URL, RESOURCE_ATTRIBUTES_VERSION as RESOURCE_ATTRIBUTES_VERSION
 from .exporters.console import ConsoleColorsValues as ConsoleColorsValues, ConsoleLogExporter as ConsoleLogExporter, IndentedConsoleSpanExporter as IndentedConsoleSpanExporter, ShowParentsConsoleSpanExporter as ShowParentsConsoleSpanExporter, SimpleConsoleSpanExporter as SimpleConsoleSpanExporter
 from .exporters.dynamic_batch import DynamicBatchSpanProcessor as DynamicBatchSpanProcessor
 from .exporters.logs import CheckSuppressInstrumentationLogProcessorWrapper as CheckSuppressInstrumentationLogProcessorWrapper, MainLogProcessorWrapper as MainLogProcessorWrapper
-from .exporters.otlp import BodySizeCheckingOTLPSpanExporter as BodySizeCheckingOTLPSpanExporter, OTLPExporterHttpSession as OTLPExporterHttpSession, QuietLogExporter as QuietLogExporter, QuietSpanExporter as QuietSpanExporter, RetryFewerSpansSpanExporter as RetryFewerSpansSpanExporter, cleanup_disk_retryers as cleanup_disk_retryers
+from .exporters.otlp import BodySizeCheckingOTLPSpanExporter as BodySizeCheckingOTLPSpanExporter, OTLPExporterHttpSession as OTLPExporterHttpSession, QuietLogExporter as QuietLogExporter, QuietSpanExporter as QuietSpanExporter, RetryFewerSpansSpanExporter as RetryFewerSpansSpanExporter, cleanup_disk_retryers as cleanup_disk_retryers, zstd_compress as zstd_compress
 from .exporters.processor_wrapper import CheckSuppressInstrumentationProcessorWrapper as CheckSuppressInstrumentationProcessorWrapper, MainSpanProcessorWrapper as MainSpanProcessorWrapper
 from .exporters.quiet_metrics import QuietMetricExporter as QuietMetricExporter
 from .exporters.remove_pending import RemovePendingSpansExporter as RemovePendingSpansExporter
@@ -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
@@ -66,6 +67,7 @@ class ConsoleOptions:
     min_log_level: LevelName = ...
     show_project_link: bool = ...
     output: TextIO | None = ...
+    include_attributes: bool | None = ...
 
 @dataclass
 class AdvancedOptions:
@@ -78,6 +80,8 @@ class AdvancedOptions:
     emit_configuration_span: bool | None = ...
     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.1.1 → logfire_api-5.3.0}/logfire_api/_internal/config_params.pyi

@@ -12,6 +12,7 @@ from typing import Any, TypeVar
 
 T = TypeVar('T')
 PydanticPluginRecordValues: Incomplete
+CompressionValues: Incomplete
 
 @dataclass(slots=True)
 class ConfigParam:
@@ -45,6 +46,7 @@ CONSOLE_SPAN_STYLE: Incomplete
 CONSOLE_INCLUDE_TIMESTAMP: Incomplete
 CONSOLE_INCLUDE_TAGS: Incomplete
 CONSOLE_VERBOSE: Incomplete
+CONSOLE_INCLUDE_ATTRIBUTES: Incomplete
 CONSOLE_MIN_LOG_LEVEL: Incomplete
 CONSOLE_SHOW_PROJECT_LINK: Incomplete
 PYDANTIC_PLUGIN_RECORD: Incomplete
@@ -56,6 +58,8 @@ 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
 CONFIG_PARAMS: Incomplete

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/_internal/exporters/console.pyi

@@ -35,7 +35,7 @@ class SimpleConsoleSpanExporter(SpanExporter):
     This simple version does not indent spans based on their parent(s), instead spans are printed as a
     flat list.
     """
-    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info') -> None: ...
+    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info', include_attributes: bool | None = None) -> None: ...
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         """Export the spans to the console."""
     def export_record(self, span: Record) -> None:
@@ -52,7 +52,7 @@ class IndentedConsoleSpanExporter(SimpleConsoleSpanExporter):
     Spans are intended based simply on how many parents they have. This will work well when spans don't overlap,
     but will be hard to understand when multiple spans are in progress at the same time.
     """
-    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info') -> None: ...
+    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info', include_attributes: bool | None = None) -> None: ...
     def export_record(self, span: Record) -> None:
         """Get the span indent based on `self._indent_level`, then print the span with that indent."""
 
@@ -63,7 +63,7 @@ class ShowParentsConsoleSpanExporter(SimpleConsoleSpanExporter):
     the previously displayed span is not the parent or sibling of a span, parents are printed (with "dim" color)
     so it\'s easy (or as easy as possible in a terminal) to understand how nested spans are related.
     '''
-    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info') -> None: ...
+    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info', include_attributes: bool | None = None) -> None: ...
     def export_record(self, span: Record) -> None:
         """Print any parent spans which aren't in the current stack of displayed spans, then print this span."""
 

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/_internal/exporters/otlp.pyi

@@ -1,4 +1,5 @@
 import atexit
+import logging
 import requests
 from ..constants import ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, HTTP_CONNECT_TIMEOUT as HTTP_CONNECT_TIMEOUT, OTLP_MAX_INT_SIZE as OTLP_MAX_INT_SIZE, log_level_attributes as log_level_attributes
 from ..http_transport import install_connection_policy as install_connection_policy
@@ -17,19 +18,46 @@ from opentelemetry.sdk.trace.export import SpanExportResult
 from pathlib import Path
 from requests import Session
 from threading import Thread
-from typing import Any
+from typing import Any, Protocol
+from typing_extensions import Buffer
+
+class _OTLPExportResult(Protocol):
+    success: bool
+    status_code: int | None
+    error: Exception | None
+
+class _OTLPClient(Protocol):
+    def export(self, data: bytes) -> _OTLPExportResult: ...
+    def shutdown(self) -> None: ...
+
+class _QuietConnectionErrorLogger(logging.LoggerAdapter):
+    def error(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+
+class _BodySizeCheckingOTLPClient:
+    client: Incomplete
+    exporter: Incomplete
+    def __init__(self, client: _OTLPClient, exporter: BodySizeCheckingOTLPSpanExporter) -> None: ...
+    def export(self, data: bytes) -> _OTLPExportResult: ...
+    def shutdown(self) -> None: ...
+
+class ZstdCompressFn(Protocol):
+    """Signature of `compression.zstd.compress` and `backports.zstd.compress`."""
+    def __call__(self, data: Buffer, level: int | None = None, options: Mapping[int, int] | None = None, zstd_dict: Any = None) -> bytes: ...
+
+zstd_compress: ZstdCompressFn | None
 
 @atexit.register
 def cleanup_disk_retryers() -> None: ...
 
 class BodySizeCheckingOTLPSpanExporter(OTLPSpanExporter):
     max_body_size: Incomplete
+    current_num_spans: int
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def export(self, spans: Sequence[ReadableSpan]): ...
 
 class OTLPExporterHttpSession(Session):
     """A requests.Session subclass that defers failed requests to a DiskRetryer."""
-    def __init__(self) -> None: ...
+    def __init__(self, *, _use_zstd: bool = False) -> None: ...
     def request(self, method: str, url: str, **kwargs: Any): ...
     def post(self, url: str, data: bytes, **kwargs: Any): ...
     @cached_property

{logfire_api-5.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.0}/logfire_api/_internal/integrations/mcp.pyi

@@ -1,7 +1,12 @@
+from collections.abc import Awaitable as Awaitable, Callable
 from logfire import LevelName as LevelName, Logfire as Logfire
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from logfire.propagate import attach_context as attach_context, get_context as get_context
-from mcp.shared.session import ReceiveRequestT as ReceiveRequestT
-from mcp.types import ClientRequest as ClientRequest, ClientResult as ClientResult, ServerRequest as ServerRequest, ServerResult as ServerResult
+from typing import Any, Protocol
+
+class _RequestResponder(Protocol):
+    """The MCP 1 responder interface used by instrumentation."""
+    request: Any
+    respond: Callable[..., Awaitable[None]]
 
 def instrument_mcp(logfire_instance: Logfire, propagate_otel_context: bool): ...

logfire_api-5.3.0/logfire_api/_internal/integrations/monty.pyi

@@ -0,0 +1,29 @@
+from _typeshed import Incomplete
+from collections.abc import Sequence
+from logfire import Logfire as Logfire
+from logfire._internal.constants import ATTRIBUTES_LOG_LEVEL_NUM_KEY as ATTRIBUTES_LOG_LEVEL_NUM_KEY, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, DISABLE_CONSOLE_KEY as DISABLE_CONSOLE_KEY
+from logfire._internal.formatter import logfire_format as logfire_format
+from logfire.version import VERSION as VERSION
+from opentelemetry._logs import LogRecord, Logger, SeverityNumber
+from opentelemetry.context import Context
+from opentelemetry.trace import Link as Link, Span, SpanKind, Tracer
+from opentelemetry.util import types as otel_types
+from typing import Any
+
+def instrument_monty(logfire_instance: Logfire) -> None:
+    """Install process-wide Monty instrumentation using Logfire's OpenTelemetry components."""
+
+class LogfireMontyTracer(Tracer):
+    """Standard OTel tracer adding settings from a specific Logfire instance."""
+    logfire: Incomplete
+    def __init__(self, logfire_instance: Logfire) -> None: ...
+    def start_span(self, name: str, context: Context | None = None, kind: SpanKind = ..., attributes: otel_types.Attributes = None, links: Sequence[Link] | None = None, start_time: int | None = None, record_exception: bool = True, set_status_on_exception: bool = True) -> Span: ...
+    start_as_current_span: Incomplete
+
+class LogfireMontyLogger(Logger):
+    """Standard OTel logger adding settings from a specific Logfire instance."""
+    logger: Incomplete
+    logfire: Incomplete
+    def __init__(self, logger: Logger, logfire_instance: Logfire) -> None: ...
+    def enabled(self, *, context: Context | None = None, severity_number: SeverityNumber | None = None, event_name: str | None = None) -> bool: ...
+    def emit(self, record: LogRecord | None = None, **kwargs: Any) -> None: ...

{logfire_api-5.1.1 → logfire_api-5.3.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.3.0/logfire_api/_internal/integrations/snowflake.pyi

@@ -0,0 +1,7 @@
+from logfire import Logfire as Logfire
+from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
+from logfire._internal.utils import handle_internal_errors as handle_internal_errors
+from snowflake.connector.connection import SnowflakeConnection
+from types import ModuleType
+
+def instrument_snowflake(logfire_instance: Logfire, conn_or_module: ModuleType | SnowflakeConnection | None, capture_parameters: bool) -> None: ...

{logfire_api-5.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.0}/logfire_api/_internal/logs.pyi

@@ -1,8 +1,9 @@
 import dataclasses
 from dataclasses import dataclass
 from logfire._internal.constants import LEVEL_NUMBERS as LEVEL_NUMBERS
-from opentelemetry._logs import LogRecord, Logger, LoggerProvider
-from opentelemetry.util.types import _ExtendedAttributes
+from opentelemetry._logs import LogRecord, Logger, LoggerProvider, SeverityNumber
+from opentelemetry.context import Context
+from opentelemetry.util.types import Attributes
 from threading import RLock
 from typing import Any, overload
 from weakref import WeakSet
@@ -15,7 +16,7 @@ class ProxyLoggerProvider(LoggerProvider):
     lock: RLock = dataclasses.field(default_factory=RLock)
     suppressed_scopes: set[str] = dataclasses.field(default_factory=set[str])
     min_level: int = ...
-    def get_logger(self, name: str, version: str | None = None, schema_url: str | None = None, attributes: _ExtendedAttributes | None = None) -> Logger: ...
+    def get_logger(self, name: str, version: str | None = None, schema_url: str | None = None, attributes: Attributes | None = None) -> Logger: ...
     def set_min_level(self, min_level: int) -> None: ...
     def suppress_scopes(self, *scopes: str) -> None: ...
     def set_provider(self, logger_provider: LoggerProvider) -> None: ...
@@ -28,10 +29,11 @@ class ProxyLogger(Logger):
     name: str
     version: str | None = ...
     schema_url: str | None = ...
-    attributes: _ExtendedAttributes | None = ...
+    attributes: Attributes | None = ...
     @overload
     def emit(self, record: LogRecord) -> None: ...
     @overload
     def emit(self, **kwargs: Any) -> None: ...
     def set_logger(self, provider: LoggerProvider) -> None: ...
+    def enabled(self, *, context: Context | None = None, severity_number: SeverityNumber | None = None, event_name: str | None = None) -> bool: ...
     def __getattr__(self, item: str): ...

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/_internal/main.pyi

@@ -51,6 +51,7 @@ from opentelemetry.trace import SpanContext, SpanKind
 from opentelemetry.util import types as otel_types
 from pydantic_evals.reporting import EvaluationReport
 from pymongo.monitoring import CommandFailedEvent as CommandFailedEvent, CommandStartedEvent as CommandStartedEvent, CommandSucceededEvent as CommandSucceededEvent
+from snowflake.connector.connection import SnowflakeConnection
 from sqlalchemy import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
 from starlette.applications import Starlette
@@ -440,16 +441,37 @@ class Logfire:
                 Pass a connection class to instrument all instances of that class.
                 By default, all connection classes are instrumented.
         """
+    def instrument_snowflake(self, conn_or_module: ModuleType | SnowflakeConnection | None = None, *, capture_parameters: bool = False) -> None:
+        """Instrument the [Snowflake Connector for Python](https://docs.snowflake.com/en/developer-guide/python-connector/python-connector) so that a span is created for each query.
+
+        Calls to `execute_async()` create a `snowflake execute async` span that measures query submission,
+        not server-side execution.
+
+        Args:
+            conn_or_module: Pass a single connection instance to instrument only that connection.
+                By default (`None`), all connections are instrumented, including ones created later.
+            capture_parameters: Set to `True` to capture query parameters as span attributes.
+                Be cautious when enabling this, as it may lead to sensitive data being captured in traces.
+                Instrumenting the same target again has no effect; the first call determines this setting,
+                and a later call with a different value emits a warning.
+                A connection keeps the setting it was instrumented with, even if the module is instrumented later.
+        """
     def instrument_mcp(self, *, propagate_otel_context: bool = True) -> None:
         """Instrument the [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk).
 
         Instruments both the client and server side. If possible, calling this in both the client and server
         processes is recommended for nice distributed traces.
 
+        This is only needed with mcp 1.x. Version 2 of the SDK (which fastmcp 4 depends on) emits
+        OpenTelemetry spans and propagates the trace context via `_meta` by itself, so with it
+        `logfire.configure()` is all that's needed. Calling this method there does nothing
+        except emit a `UserWarning` saying so.
+
         Args:
             propagate_otel_context: Whether to enable propagation of the OpenTelemetry context
                 for distributed tracing.
                 Set to False to prevent setting extra fields like `traceparent` on the metadata of requests.
+                Ignored with mcp 2, which always propagates the context.
         """
     def instrument_claude_agent_sdk(self) -> AbstractContextManager[None]:
         """Instrument the [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview).
@@ -488,6 +510,16 @@ class Logfire:
     def instrument_pydantic_ai(self, obj: pydantic_ai.Agent | None = None, /, *, include_binary_content: bool | None = None, include_content: bool | None = None, version: Literal[1, 2, 3, 4, 5] | None = None, event_mode: Literal['attributes', 'logs'] | None = None, **kwargs: Any) -> None: ...
     @overload
     def instrument_pydantic_ai(self, obj: pydantic_ai.models.Model, /, *, include_binary_content: bool | None = None, include_content: bool | None = None, version: Literal[1, 2, 3, 4, 5] | None = None, event_mode: Literal['attributes', 'logs'] | None = None, **kwargs: Any) -> pydantic_ai.models.Model: ...
+    def instrument_monty(self) -> None:
+        """Instrument Pydantic Monty.
+
+        Call this once after [`configure()`][logfire.configure] and before creating a Monty pool.
+        The first call selects the Logfire instance and its settings for the whole process;
+        subsequent calls do not replace them.
+
+        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 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.
 
@@ -906,6 +938,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.
@@ -1517,7 +1553,6 @@ class FastLogfireSpan:
 
 class LogfireSpan(ReadableSpan):
     def __init__(self, span_name: str, otlp_attributes: dict[str, otel_types.AttributeValue], tracer: _ProxyTracer, json_schema_properties: JsonSchemaProperties, links: Sequence[tuple[SpanContext, otel_types.Attributes]], span_kind: SpanKind = ...) -> None: ...
-    def __getattr__(self, name: str) -> Any: ...
     def __enter__(self) -> LogfireSpan: ...
     @handle_internal_errors
     def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None: ...
@@ -1568,7 +1603,7 @@ class NoopSpan:
 
     TODO this should also be used when tracing is disabled, e.g. before `logfire.configure()` has been called.
     """
-    def __init__(self, /, *_args: Any, **__kwargs: Any) -> None: ...
+    def __init__(self, *_args: Any, **__kwargs: Any) -> None: ...
     def __getattr__(self, _name: str) -> Any: ...
     def __enter__(self) -> NoopSpan: ...
     def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None: ...

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/_internal/metrics.pyi

@@ -2,6 +2,7 @@ import dataclasses
 from .utils import handle_internal_errors as handle_internal_errors
 from abc import ABC
 from collections.abc import Sequence
+from opentelemetry.context import Context
 from opentelemetry.metrics import CallbackT as CallbackT, Counter, Histogram, Instrument, Meter, MeterProvider, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter, _Gauge as Gauge
 from opentelemetry.util.types import Attributes
 from threading import Lock
@@ -43,10 +44,10 @@ class _ProxyInstrument(ABC, Generic[InstrumentT]):
         """Called when a real meter is set on the creating _ProxyMeter."""
 
 class _ProxyCounter(_ProxyInstrument[Counter], Counter):
-    def add(self, amount: int | float, attributes: Attributes | None = None, *args: Any, **kwargs: Any) -> None: ...
+    def add(self, amount: int | float, attributes: Attributes | None = None, context: Context | None = None, *args: Any, **kwargs: Any) -> None: ...
 
 class _ProxyHistogram(_ProxyInstrument[Histogram], Histogram):
-    def record(self, amount: int | float, attributes: Attributes | None = None, *args: Any, **kwargs: Any) -> None: ...
+    def record(self, amount: int | float, attributes: Attributes | None = None, context: Context | None = None, *args: Any, **kwargs: Any) -> None: ...
 
 class _ProxyObservableCounter(_ProxyInstrument[ObservableCounter], ObservableCounter): ...
 class _ProxyObservableGauge(_ProxyInstrument[ObservableGauge], ObservableGauge): ...

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/_internal/tracer.pyi

@@ -1,8 +1,8 @@
 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_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 .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, is_instrumentation_suppressed as is_instrumentation_suppressed, sha256_string as sha256_string
 from _typeshed import Incomplete
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
@@ -70,7 +70,6 @@ class _LogfireWrappedSpan(trace_api.Span, ReadableSpan):
     def record_exception(self, exception: BaseException, attributes: otel_types.Attributes = None, timestamp: int | None = None, escaped: bool = False) -> None: ...
     def increment_metric(self, name: str, attributes: Mapping[str, otel_types.AttributeValue], value: float) -> None: ...
     def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None: ...
-    def __getattr__(self, name: str) -> Any: ...
 
 def get_parent_span(span: ReadableSpan) -> _LogfireWrappedSpan | None: ...
 

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/_internal/utils.pyi

@@ -18,9 +18,6 @@ from types import TracebackType
 from typing import Any, ParamSpec, TypeVar, TypedDict
 
 _ = BaseExceptionGroup
-
-class BaseExceptionGroup(BaseException):
-    """Stub for BaseExceptionGroup for Python < 3.11."""
 SysExcInfo = tuple[type[BaseException], BaseException, TracebackType | None] | tuple[None, None, None]
 P = ParamSpec('P')
 T = TypeVar('T')

{logfire_api-5.1.1 → logfire_api-5.3.0}/logfire_api/experimental/api_client.pyi

@@ -6,16 +6,12 @@ from httpx._client import BaseClient
 from logfire._internal.config import get_base_url_from_token as get_base_url_from_token
 from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 from pydantic_evals import Case, Dataset
-from pydantic_evals.evaluators import Evaluator, ReportEvaluator
+from pydantic_evals.evaluators import Evaluator as Evaluator, ReportEvaluator as ReportEvaluator
 from types import TracebackType
 from typing import Any, Generic, Literal, overload
 from typing_extensions import NotRequired, Self, TypeForm, TypeVar, TypedDict
 from uuid import UUID
 
-Case = Any
-Dataset = Any
-Evaluator = Any
-ReportEvaluator = Any
 DEFAULT_TIMEOUT: Incomplete
 T = TypeVar('T', bound=BaseClient)
 InputsT = TypeVar('InputsT')

{logfire_api-5.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.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.1.1 → logfire_api-5.3.0}/logfire_api/query_client.pyi

@@ -7,16 +7,33 @@ from types import TracebackType
 from typing import Any, Generic, TypeVar, TypedDict
 from typing_extensions import Self
 
-__all__ = ['QueryExecutionError', 'QueryRequestError', 'InfoRequestError', 'UnexpectedResponseError', 'ReadTokenInfo', 'ColumnDetails', 'RowQueryResults', 'LogfireQueryClient', 'AsyncLogfireQueryClient']
+__all__ = ['QueryExecutionError', 'QueryRequestError', 'InfoRequestError', 'UnexpectedResponseError', 'QueryRateLimitedError', 'ReadTokenInfo', 'ColumnDetails', 'RowQueryResults', 'LogfireQueryClient', 'AsyncLogfireQueryClient']
 
-class QueryExecutionError(RuntimeError):
+class _ProblemDetailsMixin:
+    """Additional details about an error response.
+
+    The server sends an [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) problem detail body when the client
+    asks for one. When the server sends a different body, `problem` is `None`, and the other attributes are
+    `None` unless the response has a `Retry-After` header.
+    """
+    problem: dict[str, Any] | None
+    problem_type: str | None
+    retryable: bool | None
+    retry_after: float | None
+
+class QueryExecutionError(_ProblemDetailsMixin, RuntimeError):
     """Raised when the query execution fails on the server."""
-class QueryRequestError(RuntimeError):
+class QueryRequestError(_ProblemDetailsMixin, RuntimeError):
     """Raised when the query request is invalid."""
 class InfoRequestError(RuntimeError):
     """Raised when the request for read token info fails because of unavailable information."""
-class UnexpectedResponseError(RuntimeError):
+class UnexpectedResponseError(_ProblemDetailsMixin, RuntimeError):
     """Raised when the API responds with an unexpected status code, such as a `5xx` server error."""
+class QueryRateLimitedError(UnexpectedResponseError):
+    """Raised when the API responds with status code `429` because the request was rate limited.
+
+    Use `retry_after` to find how long to wait before the next request.
+    """
 
 class ReadTokenInfo(TypedDict, total=False):
     """Information about the read token."""

{logfire_api-5.1.1 → logfire_api-5.3.0}/pyproject.toml

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