logfire-api 4.41.0__tar.gz → 5.1.0__tar.gz

{logfire_api-4.41.0 → logfire_api-5.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 4.41.0
+Version: 5.1.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-4.41.0 → logfire_api-5.1.0}/logfire_api/__init__.py

@@ -124,7 +124,8 @@ except ImportError:
             def with_settings(self, *args, **kwargs) -> Logfire:
                 return self
 
-            def force_flush(self, *args, **kwargs) -> None: ...
+            def force_flush(self, *args, **kwargs) -> bool:
+                return True
 
             def log_slow_async_callbacks(self, *args, **kwargs) -> None:  # pragma: no cover
                 return nullcontext()
@@ -166,6 +167,9 @@ except ImportError:
 
             def instrument_starlette(self, *args, **kwargs) -> None: ...
 
+            def instrument_litestar(self, app, *args, **kwargs):
+                return app
+
             def instrument_django(self, *args, **kwargs) -> None: ...
 
             def instrument_psycopg(self, *args, **kwargs) -> None: ...
@@ -255,6 +259,7 @@ except ImportError:
         instrument_django = DEFAULT_LOGFIRE_INSTANCE.instrument_django
         instrument_flask = DEFAULT_LOGFIRE_INSTANCE.instrument_flask
         instrument_starlette = DEFAULT_LOGFIRE_INSTANCE.instrument_starlette
+        instrument_litestar = DEFAULT_LOGFIRE_INSTANCE.instrument_litestar
         instrument_aiohttp_client = DEFAULT_LOGFIRE_INSTANCE.instrument_aiohttp_client
         instrument_aiohttp_server = DEFAULT_LOGFIRE_INSTANCE.instrument_aiohttp_server
         instrument_sqlalchemy = DEFAULT_LOGFIRE_INSTANCE.instrument_sqlalchemy

{logfire_api-4.41.0 → logfire_api-5.1.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_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_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']
 
 DEFAULT_LOGFIRE_INSTANCE = Logfire()
 span = DEFAULT_LOGFIRE_INSTANCE.span
@@ -44,6 +44,7 @@ instrument_psycopg = DEFAULT_LOGFIRE_INSTANCE.instrument_psycopg
 instrument_django = DEFAULT_LOGFIRE_INSTANCE.instrument_django
 instrument_flask = DEFAULT_LOGFIRE_INSTANCE.instrument_flask
 instrument_starlette = DEFAULT_LOGFIRE_INSTANCE.instrument_starlette
+instrument_litestar = DEFAULT_LOGFIRE_INSTANCE.instrument_litestar
 instrument_aiohttp_client = DEFAULT_LOGFIRE_INSTANCE.instrument_aiohttp_client
 instrument_aiohttp_server = DEFAULT_LOGFIRE_INSTANCE.instrument_aiohttp_server
 instrument_sqlalchemy = DEFAULT_LOGFIRE_INSTANCE.instrument_sqlalchemy

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/cli/__init__.pyi

@@ -7,6 +7,8 @@ __all__ = ['main', 'logfire_info']
 class SavedReadToken(NamedTuple):
     token: str
     base_url: str
+    organization: str
+    project_name: str
 
 def logfire_info() -> str:
     """Show versions of logfire, OS and related packages."""

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/cli/run.pyi

@@ -14,6 +14,7 @@ TARGET_PACKAGE_ALIASES: Incomplete
 INSTRUMENTATION_CALL_ARGUMENTS: Incomplete
 MINIMUM_INSTRUMENTATION_VERSIONS: Incomplete
 OTEL_INSTRUMENTATION_MAP: Incomplete
+INSTRUMENTATION_TO_EXTRA: dict[str, str]
 
 @dataclass(frozen=True, order=True)
 class InstrumentationRecommendation:

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/config.pyi

@@ -16,7 +16,7 @@ from .exporters.remove_pending import RemovePendingSpansExporter as RemovePendin
 from .exporters.test import TestExporter as TestExporter
 from .forwarding import OTLPForwardingManager as OTLPForwardingManager
 from .integrations.executors import instrument_executors as instrument_executors
-from .interactive import require_answer as require_answer
+from .interactive import ask_or_default as ask_or_default, ask_required as ask_required, require_answer as require_answer
 from .logs import ProxyLoggerProvider as ProxyLoggerProvider
 from .main import Logfire as Logfire
 from .metrics import ProxyMeterProvider as ProxyMeterProvider
@@ -24,7 +24,7 @@ from .scrubbing import BaseScrubber as BaseScrubber, NOOP_SCRUBBER as NOOP_SCRUB
 from .server_response import ServerResponseCallback as ServerResponseCallback, install_logfire_response_hook as install_logfire_response_hook
 from .stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 from .tracer import OPEN_SPANS as OPEN_SPANS, PendingSpanProcessor as PendingSpanProcessor, ProxyTracerProvider as ProxyTracerProvider
-from .utils import SeededRandomIdGenerator as SeededRandomIdGenerator, ensure_data_dir_exists as ensure_data_dir_exists, handle_internal_errors as handle_internal_errors, platform_is_emscripten as platform_is_emscripten, suppress_instrumentation as suppress_instrumentation
+from .utils import SeededRandomIdGenerator as SeededRandomIdGenerator, ensure_data_dir_exists as ensure_data_dir_exists, handle_internal_errors as handle_internal_errors, platform_is_aws_lambda as platform_is_aws_lambda, platform_is_emscripten as platform_is_emscripten, suppress_instrumentation as suppress_instrumentation
 from _typeshed import Incomplete
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
@@ -46,8 +46,8 @@ from opentelemetry.sdk.resources import ResourceDetector
 from opentelemetry.sdk.trace import SpanProcessor
 from opentelemetry.sdk.trace.id_generator import IdGenerator
 from pathlib import Path
-from typing import Any, ClassVar, Literal, TextIO, TypedDict
-from typing_extensions import Self, Unpack
+from typing import Any, ClassVar, Literal, TextIO
+from typing_extensions import Self
 
 CREDENTIALS_FILENAME: str
 COMMON_REQUEST_HEADERS: Incomplete
@@ -140,9 +140,7 @@ class LocalVariablesOptions:
     instrument: bool = ...
     template_mismatch_policy: TemplateMismatchPolicy = ...
 
-class DeprecatedKwargs(TypedDict): ...
-
-def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | list[str] | None = None, api_key: str | None = None, service_name: str | None = None, service_version: str | None = None, environment: str | None = None, resource_attributes: Mapping[str, Any] | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | str | None = None, data_dir: Path | str | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, min_level: int | LevelName | None = None, add_baggage_to_attributes: bool = True, code_source: CodeSource | None = None, variables: VariablesOptions | LocalVariablesOptions | None = None, distributed_tracing: bool | None = None, advanced: AdvancedOptions | None = None, **deprecated_kwargs: Unpack[DeprecatedKwargs]) -> Logfire:
+def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | list[str] | None = None, api_key: str | None = None, service_name: str | None = None, service_version: str | None = None, environment: str | None = None, resource_attributes: Mapping[str, Any] | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | str | None = None, data_dir: Path | str | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, min_level: int | LevelName | None = None, add_baggage_to_attributes: bool = True, code_source: CodeSource | None = None, variables: VariablesOptions | LocalVariablesOptions | None = None, distributed_tracing: bool | None = None, advanced: AdvancedOptions | None = None) -> Logfire:
     """Configure the logfire SDK.
 
     Args:
@@ -270,13 +268,13 @@ class LogfireConfig(_LogfireConfigData):
     def initialize(self) -> None:
         """Configure internals to start exporting traces and metrics."""
     def force_flush(self, timeout_millis: int = 30000) -> bool:
-        """Force flush all spans and metrics.
+        """Force flush all telemetry and forwarding pipelines.
 
         Args:
             timeout_millis: The timeout in milliseconds.
 
         Returns:
-            Whether the flush of spans was successful.
+            Whether every component that reports a status flushed successfully.
         """
     def shutdown(self, timeout_millis: int = 30000, flush: bool = True) -> bool:
         """Shut down variables, forwarding, traces, logs, and metrics."""

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/exporters/otlp.pyi

@@ -1,15 +1,17 @@
 import atexit
 import requests
-from ..constants import HTTP_CONNECT_TIMEOUT as HTTP_CONNECT_TIMEOUT
-from ..utils import logger as logger, platform_is_emscripten as platform_is_emscripten
+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 ..stack_info import STACK_INFO_KEYS as STACK_INFO_KEYS
+from ..utils import logger as logger, platform_is_emscripten as platform_is_emscripten, truncate_string as truncate_string
 from .wrapper import WrapperLogExporter as WrapperLogExporter, WrapperSpanExporter as WrapperSpanExporter
 from _typeshed import Incomplete
 from collections import deque
 from collections.abc import Mapping, Sequence
 from functools import cached_property
+from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk._logs import ReadableLogRecord as ReadableLogRecord
-from opentelemetry.sdk.trace import ReadableSpan as ReadableSpan
+from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExportResult
 from pathlib import Path
 from requests import Session
@@ -61,7 +63,7 @@ class RetryFewerSpansSpanExporter(WrapperSpanExporter):
 class BodyTooLargeError(Exception):
     size: Incomplete
     max_size: Incomplete
-    def __init__(self, size: int, max_size: int) -> None: ...
+    def __init__(self, size: int, max_size: int | None) -> None: ...
 
 class SuppressedConnectionError(Exception): ...
 

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/forwarding.pyi

@@ -4,14 +4,16 @@ from collections.abc import Callable as Callable, Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum
 from logfire._internal.exporters.otlp import OTLPExporterHttpSession as OTLPExporterHttpSession
+from logfire._internal.main import Logfire as Logfire
 from logfire._internal.server_response import install_logfire_response_hook as install_logfire_response_hook
 from logfire._internal.utils import suppress_instrumentation as suppress_instrumentation
-from logfire.experimental.forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
 from logfire.types import ServerResponseCallback as ServerResponseCallback
 from logfire.version import VERSION as VERSION
 from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceResponse
 from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import ExportMetricsServiceResponse
 from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceResponse
+from starlette.requests import Request
+from starlette.responses import Response
 from threading import Thread
 from typing import Literal
 
@@ -48,6 +50,13 @@ class ForwardingErrorResponse:
     status_code: int
     content: bytes
 
+@dataclass
+class ForwardExportRequestResponse:
+    """Response returned from a forwarded export request to Logfire."""
+    status_code: int
+    headers: Mapping[str, str]
+    content: bytes
+
 @dataclass(frozen=True)
 class ForwardingAdmissionResult:
     response: Literal['success', 'partial_success']
@@ -81,5 +90,15 @@ class OTLPForwardingManager:
 
 def parse_forwarding_content_type(content_type: str) -> ForwardingContentType | None: ...
 def build_forwarding_request(*, path: str, headers: Mapping[str, str], body: bytes, max_body_size: int = ...) -> ForwardingRequest | ForwardingErrorResponse: ...
+def forward_export_request(*, path: str, headers: Mapping[str, str], body: bytes, logfire_instance: Logfire | None = None, max_body_size: int = ...) -> ForwardExportRequestResponse:
+    """Forward an export request to the Logfire API.
+
+    See the Logfire.forward_export_request method for more details.
+    """
+async def logfire_proxy(request: Request, *, logfire_instance: Logfire | None = None, max_body_size: int = ...) -> Response:
+    """A Starlette/FastAPI handler to proxy requests to Logfire.
+
+    See the Logfire.forward_export_request_starlette method for more details.
+    """
 def build_success_response(request: ForwardingRequest) -> ForwardExportRequestResponse: ...
 def build_partial_success_response(request: ForwardingRequest, *, message: str) -> ForwardExportRequestResponse: ...

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/integrations/flask.pyi

@@ -1,5 +1,4 @@
 from flask.app import Flask
-from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 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

logfire_api-5.1.0/logfire_api/_internal/integrations/google_genai.pyi

@@ -0,0 +1,12 @@
+import logfire
+from _typeshed import Incomplete
+from logfire._internal.utils import safe_repr as safe_repr
+from typing import Any
+
+CAPTURE_MESSAGE_CONTENT_ENV_VAR: str
+LEGACY_CAPTURE_MESSAGE_CONTENT_VALUES: Incomplete
+EMIT_EVENT_ENV_VAR: str
+original_flatten_compound_value: Incomplete
+
+def wrapped_flatten_compound_value(key: str, value: Any, *args: Any, **kwargs: Any): ...
+def instrument_google_genai(logfire_instance: logfire.Logfire, **kwargs: Any): ...

logfire_api-5.1.0/logfire_api/_internal/integrations/litestar.pyi

@@ -0,0 +1,7 @@
+from .asgi import ASGIApp as ASGIApp, ASGIInstrumentKwargs as ASGIInstrumentKwargs, instrument_asgi as instrument_asgi
+from litestar import Litestar
+from logfire import Logfire as Logfire
+from typing_extensions import Unpack
+
+def instrument_litestar(logfire_instance: Logfire, app: Litestar, *, record_send_receive: bool = False, capture_headers: bool = False, **kwargs: Unpack[ASGIInstrumentKwargs]) -> ASGIApp:
+    """Wrap a Litestar app with OpenTelemetry middleware configured for Logfire."""

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/integrations/openai_agents.pyi

@@ -7,7 +7,7 @@ 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 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_output_events as responses_output_events
 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
@@ -29,6 +29,7 @@ class LogfireTraceProviderWrapper:
 class LogfireSpanHelper:
     span: LogfireSpan
     parent: Trace | Span[Any] | None = ...
+    openai_cost_provider_url: str | None = ...
     def start(self, mark_as_current: bool): ...
     def end(self, reset_current: bool): ...
     def maybe_detach(self, reset_current: bool): ...
@@ -94,7 +95,7 @@ class LogfireSpanWrapper(LogfireWrapperBase[Span[TSpanData]], Span[TSpanData]):
     @property
     def tracing_api_key(self) -> str | None: ...
 
-def attributes_from_span_data(span_data: SpanData, msg_template: str) -> dict[str, Any]: ...
+def attributes_from_span_data(span_data: SpanData, msg_template: str, openai_cost_provider_url: str | None = None) -> dict[str, Any]: ...
 def get_basic_response_attributes(response: Response): ...
-def get_magic_response_attributes() -> dict[str, Any]: ...
+def get_magic_response_attributes() -> tuple[dict[str, Any], str | None]: ...
 def get_response_span_events(span: ResponseSpanData): ...

logfire_api-5.1.0/logfire_api/_internal/interactive.pyi

@@ -0,0 +1,53 @@
+from collections.abc import Callable
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from typing import TypeVar
+
+T = TypeVar('T')
+
+class NonInteractiveError(LogfireConfigError):
+    """A prompt was needed, but nobody could answer it.
+
+    Carries the guidance the user needs rather than a traceback: the CLI catches this and
+    prints `message` before exiting non-zero. Raised either because `--non-interactive`
+    said so up front (`require_answer`), or because stdin ran out before an answer arrived
+    (`ask_required`) -- the same question/remedy structure either way (only the reason
+    line differs), since both mean the same thing to whoever reads it.
+    """
+
+def set_non_interactive(value: bool) -> None:
+    """Record whether prompts are allowed. Called once, from CLI argument parsing."""
+def is_non_interactive() -> bool:
+    """Whether the caller declared that it cannot answer prompts."""
+def require_answer(question: str, remedy: str, *more_remedies: str) -> None:
+    """Fail instead of prompting, when the caller said it cannot answer.
+
+    At least one remedy is required by the signature: refusing to prompt while offering no
+    way forward just moves the dead end, and telling the caller what to pass is the entire
+    value of failing here rather than blocking.
+
+    Args:
+        question: what would have been asked, in plain terms.
+        remedy: a runnable suggestion.
+        more_remedies: further suggestions. Each is printed on its own line, so each must
+            be individually pasteable -- `--org a|b` is a shell pipeline, not a suggestion.
+    """
+def ask_or_default(ask: Callable[[], T], default: T) -> T:
+    '''Run a prompt, falling back to `default` when stdin runs out before an answer does.
+
+    Mirrors accepting a blank Enter keypress: the caller already declared what "no answer"
+    means by passing this SAME value as the prompt\'s own `default=`, so an exhausted stdin
+    reaches the outcome a person pressing Enter would, rather than an `EOFError` traceback.
+    Only for prompts where that default is genuinely safe to assume -- see `ask_required`
+    for one that has no safe default to fall back on.
+    '''
+def ask_required(ask: Callable[[], T], question: str, remedy: str, *more_remedies: str) -> T:
+    """Run a prompt that has no safe default, raising if stdin runs out before an answer does.
+
+    The reactive half of `require_answer`'s proactive check: that covers a caller who
+    declared `--non-interactive` up front, this covers one that did not but ran out of
+    input anyway -- a command copied out of the docs into an agent, mid-conversation.
+    Raises the same `NonInteractiveError` structure `require_answer` would -- question,
+    then reason, then remedies -- with a reason line naming stdin instead of the flag,
+    since both mean the same thing to whoever reads it: there was no answer, and here is
+    how to supply one.
+    """

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/logs.pyi

@@ -3,7 +3,7 @@ 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 threading import Lock
+from threading import RLock
 from typing import Any, overload
 from weakref import WeakSet
 
@@ -12,7 +12,7 @@ class ProxyLoggerProvider(LoggerProvider):
     """A logger provider that wraps another internal logger provider allowing it to be re-assigned."""
     provider: LoggerProvider
     loggers: WeakSet[ProxyLogger] = dataclasses.field(default_factory=WeakSet['ProxyLogger'])
-    lock: Lock = dataclasses.field(default_factory=Lock)
+    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: ...

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/main.pyi

@@ -7,7 +7,6 @@ import pydantic_ai
 import pydantic_ai.models
 import requests
 from . import async_ as async_
-from ..experimental.forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
 from ..integrations.aiohttp_client import RequestHook as AiohttpClientRequestHook, ResponseHook as AiohttpClientResponseHook
 from ..integrations.flask import CommenterOptions as FlaskCommenterOptions, RequestHook as FlaskRequestHook, ResponseHook as FlaskResponseHook
 from ..integrations.httpx import AsyncRequestHook as HttpxAsyncRequestHook, AsyncResponseHook as HttpxAsyncResponseHook, RequestHook as HttpxRequestHook, ResponseHook as HttpxResponseHook
@@ -22,6 +21,7 @@ from .config import GLOBAL_CONFIG as GLOBAL_CONFIG, LogfireConfig as LogfireConf
 from .config_params import PydanticPluginRecordValues as PydanticPluginRecordValues
 from .constants import ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY, 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_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, DISABLE_CONSOLE_KEY as DISABLE_CONSOLE_KEY, LEVEL_NUMBERS as LEVEL_NUMBERS, LevelName as LevelName, OTLP_MAX_INT_SIZE as OTLP_MAX_INT_SIZE, log_level_attributes as log_level_attributes
 from .formatter import logfire_format as logfire_format, logfire_format_with_magic as logfire_format_with_magic
+from .forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
 from .instrument import instrument as instrument
 from .integrations.asgi import ASGIApp as ASGIApp, ASGIInstrumentKwargs as ASGIInstrumentKwargs
 from .integrations.aws_lambda import LambdaEvent as LambdaEvent, LambdaHandler as LambdaHandler
@@ -42,6 +42,7 @@ from contextlib import AbstractContextManager
 from django.http import HttpRequest as HttpRequest, HttpResponse as HttpResponse
 from fastapi import FastAPI
 from flask.app import Flask
+from litestar import Litestar
 from opentelemetry.context import Context as Context
 from opentelemetry.instrumentation.asgi.types import ClientRequestHook, ClientResponseHook, ServerRequestHook
 from opentelemetry.metrics import CallbackT as CallbackT, Counter, Histogram, UpDownCounter, _Gauge as Gauge
@@ -367,13 +368,13 @@ class Logfire:
             A new Logfire instance with the given settings applied.
         """
     def force_flush(self, timeout_millis: int = 3000) -> bool:
-        """Force flush all spans and metrics.
+        """Force flush all telemetry and forwarding pipelines.
 
         Args:
             timeout_millis: The timeout in milliseconds.
 
         Returns:
-            Whether the flush of spans was successful.
+            Whether every component that reports a status flushed successfully.
         """
     def url_from_eval(self, report: EvaluationReport[Any, Any, Any]) -> str | None:
         """Generate a Logfire URL to view an evaluation report.
@@ -478,8 +479,10 @@ class Logfire:
                 - `off`: Disable instrumentation.
             include:
                 By default, third party modules are not instrumented. This option allows you to include specific modules.
+                Each entry is a regular expression matched against `module::ModelName` and anchored at the end,
+                so use e.g. `openai.*` rather than `openai`, which would only match a model named `openai`.
             exclude:
-                Exclude specific modules from instrumentation.
+                Exclude specific modules from instrumentation. Matched the same way as `include`.
         """
     @overload
     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: ...
@@ -528,7 +531,7 @@ class Logfire:
                 without waiting for the context manager to be opened,
                 i.e. it's not necessary to use this as a context manager.
         """
-    def instrument_openai(self, openai_client: openai.OpenAI | openai.AsyncOpenAI | type[openai.OpenAI] | type[openai.AsyncOpenAI] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 1) -> AbstractContextManager[None]:
+    def instrument_openai(self, openai_client: openai.OpenAI | openai.AsyncOpenAI | type[openai.OpenAI] | type[openai.AsyncOpenAI] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 2) -> AbstractContextManager[None]:
         '''Instrument an OpenAI client so that spans are automatically created for each request.
 
         This instruments the [standard OpenAI SDK](https://pypi.org/project/openai/) package, for instrumentation
@@ -579,14 +582,15 @@ class Logfire:
 
             version: The version(s) of the span attribute format to use:
 
-                - `1` (the default): Uses `request_data` and `response_data` attributes.
-                - `\'latest\'`: Uses OpenTelemetry Gen AI semantic convention attributes
+                - `1`: Uses the legacy `request_data` and `response_data` attributes.
+                - `2` (the default): Uses OpenTelemetry Gen AI semantic convention attributes
                   (`gen_ai.input.messages`, `gen_ai.output.messages`, etc.) and omits the full
                   `response_data` attribute. A minimal `request_data` (e.g. `{"model": ...}`) is
-                  still recorded for message template compatibility. This format may change between
-                  releases.
-                - `[1, \'latest\']`: Emits both the full legacy attributes and the semantic convention
-                  attributes simultaneously, useful for migration and testing.
+                  still recorded for message template compatibility.
+                - `\'latest\'`: Uses the latest format, which is currently identical to version 2.
+                  Unlike a numbered version, this format may change between releases.
+                - `[1, 2]` or `[1, \'latest\']`: Emits both the full legacy attributes and the semantic
+                  convention attributes simultaneously, useful for migration and testing.
 
         Returns:
             A context manager that will revert the instrumentation when exited.
@@ -598,7 +602,7 @@ class Logfire:
         For instrumentation of the standard OpenAI SDK package,
         see [`instrument_openai()`][logfire.Logfire.instrument_openai].
         """
-    def instrument_anthropic(self, anthropic_client: anthropic.Anthropic | anthropic.AsyncAnthropic | _AnthropicBedrock | _AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[_AnthropicBedrock] | type[_AsyncAnthropicBedrock] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 1) -> AbstractContextManager[None]:
+    def instrument_anthropic(self, anthropic_client: anthropic.Anthropic | anthropic.AsyncAnthropic | _AnthropicBedrock | _AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[_AnthropicBedrock] | type[_AsyncAnthropicBedrock] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 2) -> AbstractContextManager[None]:
         '''Instrument an Anthropic client so that spans are automatically created for each request.
 
         The following methods are instrumented for both the sync and async clients:
@@ -644,14 +648,15 @@ class Logfire:
 
             version: The version(s) of the span attribute format to use:
 
-                - `1` (the default): Uses `request_data` and `response_data` attributes.
-                - `\'latest\'`: Uses OpenTelemetry Gen AI semantic convention attributes
+                - `1`: Uses the legacy `request_data` and `response_data` attributes.
+                - `2` (the default): Uses OpenTelemetry Gen AI semantic convention attributes
                   (`gen_ai.input.messages`, `gen_ai.output.messages`, etc.) and omits the full
                   `response_data` attribute. A minimal `request_data` (e.g. `{"model": ...}`) is
-                  still recorded for message template compatibility. This format may change between
-                  releases.
-                - `[1, \'latest\']`: Emits both the full legacy attributes and the semantic convention
-                  attributes simultaneously, useful for migration and testing.
+                  still recorded for message template compatibility.
+                - `\'latest\'`: Uses the latest format, which is currently identical to version 2.
+                  Unlike a numbered version, this format may change between releases.
+                - `[1, 2]` or `[1, \'latest\']`: Emits both the full legacy attributes and the semantic
+                  convention attributes simultaneously, useful for migration and testing.
 
         Returns:
             A context manager that will revert the instrumentation when exited.
@@ -662,7 +667,7 @@ class Logfire:
 
         !!! note
             To capture message contents (i.e. prompts and completions), set the environment variable
-            `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` to `true`.
+            `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` to `SPAN_ONLY`.
 
         Uses the `GoogleGenAiSdkInstrumentor().instrument()` method of the
         [`opentelemetry-instrumentation-google-genai`](https://pypi.org/project/opentelemetry-instrumentation-google-genai/)
@@ -796,6 +801,29 @@ class Logfire:
             response_hook: A function called right before a span is finished for the response.
             **kwargs: Additional keyword arguments to pass to the OpenTelemetry Flask instrumentation.
         """
+    def instrument_litestar(self, app: Litestar, *, capture_headers: bool = False, record_send_receive: bool = False, **kwargs: Unpack[ASGIInstrumentKwargs]) -> ASGIApp:
+        """Instrument a Litestar app to record requests with canonical route templates.
+
+        Uses `instrument_asgi()` with a Litestar route extractor, so requests to
+        `/users/1` and `/users/2` share the route `/users/{user_id}`.
+
+        Warning:
+            This method returns an ASGI wrapper instead of modifying the app in place.
+            Pass the returned app to your server. Access Litestar-specific attributes
+            through the original app.
+
+        Args:
+            app: The Litestar app to instrument.
+            capture_headers: Set to `True` to capture all request and response headers.
+            record_send_receive: Set to `True` to record low-level ASGI send and receive spans.
+                These are disabled by default to reduce noise.
+            **kwargs: Additional options for the OpenTelemetry ASGI middleware, including
+                `server_request_hook`, `client_request_hook`, `client_response_hook`,
+                `excluded_urls`, and `default_span_details`.
+
+        Returns:
+            The instrumented ASGI application.
+        """
     def instrument_starlette(self, app: Starlette, *, capture_headers: bool = False, record_send_receive: 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.
 
@@ -1231,7 +1259,7 @@ class Logfire:
         """
     def variables_get(self) -> list[Variable[Any] | TemplateVariable[Any, Any]]:
         """Get all variables registered with this Logfire instance's config."""
-    def variables_push(self, variables: list[Variable[Any] | TemplateVariable[Any, Any]] | None = None, *, dry_run: bool = False, yes: bool = False, strict: bool = False) -> bool:
+    def variables_push(self, variables: list[Variable[Any] | TemplateVariable[Any, Any]] | None = None, *, dry_run: bool = False, yes: bool = False, strict: bool = True) -> bool:
         """Push variable definitions (metadata only) to the configured variable provider.
 
         This method syncs local variable definitions with the provider:
@@ -1248,8 +1276,8 @@ class Logfire:
                 variables registered on `with_settings()` siblings.
             dry_run: If True, only show what would change without applying.
             yes: If True, skip confirmation prompt.
-            strict: If True, fail if any existing label values are incompatible with new schemas
-                or any reference errors are found.
+            strict: If True, fail on incompatible label values, missing references, or template-field issues.
+                Set to False to publish despite those issues. Reference cycles always block the push.
 
         Returns:
             True if changes were applied (or would be applied in dry_run mode), False otherwise.
@@ -1269,7 +1297,7 @@ class Logfire:
                 logfire.variables_push([feature_enabled])
             ```
         """
-    def variables_push_types(self, types: Sequence[type[Any] | tuple[type[Any], str]], *, dry_run: bool = False, yes: bool = False, strict: bool = False) -> bool:
+    def variables_push_types(self, types: Sequence[type[Any] | tuple[type[Any], str]], *, dry_run: bool = False, yes: bool = False, strict: bool = True) -> bool:
         """Push variable type definitions to the configured variable provider.
 
         Variable types are reusable schema definitions that can be referenced by variables.
@@ -1291,7 +1319,7 @@ class Logfire:
             dry_run: If True, only show what would change without applying.
             yes: If True, skip confirmation prompt.
             strict: If True, abort when existing label values are incompatible with
-                the new type schema.
+                the new type schema. Set to False to publish despite these issues.
 
         Returns:
             True if changes were applied (or would be applied in dry_run mode), False otherwise.

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/stack_info.pyi

@@ -10,7 +10,11 @@ NON_USER_CODE_PREFIXES: tuple[str, ...]
 def add_non_user_code_prefix(path: str | Path) -> None:
     """Add a path to the list of prefixes that are considered non-user code.
 
-    This prevents the stack info from including frames from the given path.
+    This has two effects for code under the given path:
+
+    - Its frames are left out of the stack info recorded on spans and logs.
+    - Its pydantic models aren't instrumented by `logfire.instrument_pydantic` unless
+      [`include`][logfire.PydanticPlugin.include] names them explicitly.
 
     This is for advanced users and shouldn't often be needed.
     By default, the following prefixes are already included:
@@ -38,14 +42,18 @@ def get_user_frame_and_stacklevel() -> tuple[FrameType | None, int]:
     See is_user_code for details.
     Returns `(None, 0)` if no such frame is found.
     """
+def is_non_user_path(path: str | Path) -> bool:
+    """Check if the file path is in a location that doesn't contain user code.
+
+    Specifically the standard library, site-packages (wherever opentelemetry is installed),
+    the logfire package, and anything registered with `add_non_user_code_prefix`.
+    """
 def is_user_code(code: CodeType) -> bool:
     """Check if the code object is from user code.
 
     A code object is not user code if:
     - It is from a file in
-        - the standard library
-        - site-packages (specifically wherever opentelemetry is installed)
-        - the logfire package
+        - a non-user location, see `is_non_user_path`
         - an unknown location (e.g. a dynamically generated code object) indicated by a filename starting with '<'
     - It is a list/dict/set comprehension.
         These are artificial frames only created before Python 3.12,

{logfire_api-4.41.0 → logfire_api-5.1.0}/logfire_api/_internal/utils.pyi

@@ -132,6 +132,14 @@ def platform_is_emscripten() -> bool:
 
     Threads cannot be created on Emscripten, so we need to avoid any code that creates threads.
     """
+def platform_is_aws_lambda() -> bool:
+    """Return True when running inside an AWS Lambda function.
+
+    Lambda freezes the execution environment between the end of the init phase and the first
+    invocation (and between invocations), so background work started during init may be
+    interrupted for minutes. `AWS_LAMBDA_FUNCTION_NAME` is set by the runtime in every Lambda
+    execution environment.
+    """
 def canonicalize_exception_traceback(exc: BaseException, seen: set[int] | None = None) -> str:
     """Return a canonical string representation of an exception traceback.