logfire-api 0.46.1__tar.gz

logfire_api-0.46.1/.gitignore

@@ -0,0 +1,10 @@
+# python generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# venv
+.venv

logfire_api-0.46.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.3
+Name: logfire-api
+Version: 0.46.1
+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>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# logfire-api
+
+Shim for the logfire SDK Python API which does nothing unless logfire is installed.
+
+This package is designed to be used by packages that want to provide opt-in integration with [Logfire](https://github.com/pydantic/logfire).
+
+The package provides a clone of the Python API exposed by the `logfire` package which does nothing if the `logfire` package is not installed, but makes real calls when it is.

logfire_api-0.46.1/README.md

@@ -0,0 +1,7 @@
+# logfire-api
+
+Shim for the logfire SDK Python API which does nothing unless logfire is installed.
+
+This package is designed to be used by packages that want to provide opt-in integration with [Logfire](https://github.com/pydantic/logfire).
+
+The package provides a clone of the Python API exposed by the `logfire` package which does nothing if the `logfire` package is not installed, but makes real calls when it is.

logfire_api-0.46.1/logfire_api/__init__.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+import importlib
+import sys
+from typing import TYPE_CHECKING, ContextManager, Literal
+from contextlib import nullcontext
+from unittest.mock import MagicMock
+
+try:
+    logfire_module = importlib.import_module('logfire')
+    sys.modules[__name__] = logfire_module
+
+except ImportError:
+    if not TYPE_CHECKING:  # pragma: no branch
+        LevelName = Literal['trace', 'debug', 'info', 'notice', 'warn', 'warning', 'error', 'fatal']
+        VERSION = '0.0.0'
+        METRICS_PREFERRED_TEMPORALITY = {}
+
+        def configure(*args, **kwargs): ...
+
+        class LogfireSpan:
+            def __getattr__(self, attr):
+                return MagicMock()  # pragma: no cover
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, *args, **kwargs) -> None: ...
+
+            @property
+            def message_template(self) -> str:  # pragma: no cover
+                return ''
+
+            @property
+            def tags(self) -> Sequence[str]:  # pragma: no cover
+                return []
+
+            @property
+            def message(self) -> str:  # pragma: no cover
+                return ''
+
+            @message.setter
+            def message(self, message: str): ...  # pragma: no cover
+
+            def is_recording(self) -> bool:  # pragma: no cover
+                return False
+
+        class Logfire:
+            def __getattr__(self, attr):
+                return MagicMock()  # pragma: no cover
+
+            def __init__(self, *args, **kwargs) -> None: ...
+
+            def span(self, *args, **kwargs) -> LogfireSpan:
+                return LogfireSpan()
+
+            def log(self, *args, **kwargs) -> None: ...
+
+            def trace(self, *args, **kwargs) -> None: ...
+
+            def debug(self, *args, **kwargs) -> None: ...
+
+            def notice(self, *args, **kwargs) -> None: ...
+
+            def info(self, *args, **kwargs) -> None: ...
+
+            def warn(self, *args, **kwargs) -> None: ...
+
+            def error(self, *args, **kwargs) -> None: ...
+
+            def fatal(self, *args, **kwargs) -> None: ...
+
+            def with_tags(self, *args, **kwargs) -> Logfire:
+                return self
+
+            def with_settings(self, *args, **kwargs) -> Logfire:
+                return self
+
+            def force_flush(self, *args, **kwargs) -> None: ...
+
+            def log_slow_async_callbacks(self, *args, **kwargs) -> None: # pragma: no branch
+                return nullcontext()
+
+            def install_auto_tracing(self, *args, **kwargs) -> None: ...
+
+            def instrument(self, *args, **kwargs):
+                def decorator(func):
+                    return func
+
+                return decorator
+
+            def instrument_fastapi(self, *args, **kwargs) -> ContextManager[None]:
+                return nullcontext()
+
+            def instrument_pymongo(self, *args, **kwargs) -> None: ...
+
+            def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
+
+            def instrument_redis(self, *args, **kwargs) -> None: ...
+
+            def instrument_flask(self, *args, **kwargs) -> None: ...
+
+            def instrument_starlette(self, *args, **kwargs) -> None: ...
+
+            def instrument_django(self, *args, **kwargs) -> None: ...
+
+            def instrument_psycopg(self, *args, **kwargs) -> None: ...
+
+            def instrument_requests(self, *args, **kwargs) -> None: ...
+
+            def instrument_httpx(self, *args, **kwargs) -> None: ...
+
+            def instrument_asyncpg(self, *args, **kwargs) -> None: ...
+
+            def instrument_anthropic(self, *args, **kwargs) -> ContextManager[None]:
+                return nullcontext()
+
+            def instrument_openai(self, *args, **kwargs) -> ContextManager[None]:
+                return nullcontext()
+
+            def instrument_aiohttp_client(self, *args, **kwargs) -> None: ...
+
+            def shutdown(self, *args, **kwargs) -> None: ...
+
+        DEFAULT_LOGFIRE_INSTANCE = Logfire()
+        span = DEFAULT_LOGFIRE_INSTANCE.span
+        log = DEFAULT_LOGFIRE_INSTANCE.log
+        trace = DEFAULT_LOGFIRE_INSTANCE.trace
+        debug = DEFAULT_LOGFIRE_INSTANCE.debug
+        notice = DEFAULT_LOGFIRE_INSTANCE.notice
+        info = DEFAULT_LOGFIRE_INSTANCE.info
+        warn = DEFAULT_LOGFIRE_INSTANCE.warn
+        error = DEFAULT_LOGFIRE_INSTANCE.error
+        fatal = DEFAULT_LOGFIRE_INSTANCE.fatal
+        with_tags = DEFAULT_LOGFIRE_INSTANCE.with_tags
+        with_settings = DEFAULT_LOGFIRE_INSTANCE.with_settings
+        force_flush = DEFAULT_LOGFIRE_INSTANCE.force_flush
+        log_slow_async_callbacks = DEFAULT_LOGFIRE_INSTANCE.log_slow_async_callbacks
+        install_auto_tracing = DEFAULT_LOGFIRE_INSTANCE.install_auto_tracing
+        instrument = DEFAULT_LOGFIRE_INSTANCE.instrument
+        instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
+        instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
+        instrument_anthropic = DEFAULT_LOGFIRE_INSTANCE.instrument_anthropic
+        instrument_asyncpg = DEFAULT_LOGFIRE_INSTANCE.instrument_asyncpg
+        instrument_httpx = DEFAULT_LOGFIRE_INSTANCE.instrument_httpx
+        instrument_requests = DEFAULT_LOGFIRE_INSTANCE.instrument_requests
+        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_aiohttp_client = DEFAULT_LOGFIRE_INSTANCE.instrument_aiohttp_client
+        instrument_sqlalchemy = DEFAULT_LOGFIRE_INSTANCE.instrument_sqlalchemy
+        instrument_redis = DEFAULT_LOGFIRE_INSTANCE.instrument_redis
+        instrument_pymongo = DEFAULT_LOGFIRE_INSTANCE.instrument_pymongo
+        shutdown = DEFAULT_LOGFIRE_INSTANCE.shutdown
+
+        def no_auto_trace(x):
+            return x
+
+        @contextmanager
+        def suppress_instrumentation():
+            yield
+
+        class ConsoleOptions:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        class TailSamplingOptions:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        class ScrubbingOptions:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        class PydanticPlugin:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        class ScrubMatch:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        class AutoTraceModule:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        class StructlogProcessor:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        class LogfireLoggingHandler:
+            def __init__(self, *args, **kwargs) -> None: ...
+
+        def load_spans_from_file(*args, **kwargs):
+            return []

logfire_api-0.46.1/logfire_api/__init__.pyi

@@ -0,0 +1,47 @@
+from ._internal.auto_trace import AutoTraceModule as AutoTraceModule
+from ._internal.auto_trace.rewrite_ast import no_auto_trace as no_auto_trace
+from ._internal.config import ConsoleOptions as ConsoleOptions, METRICS_PREFERRED_TEMPORALITY as METRICS_PREFERRED_TEMPORALITY, PydanticPlugin as PydanticPlugin, configure as configure
+from ._internal.constants import LevelName as LevelName
+from ._internal.exporters.file import load_file as load_spans_from_file
+from ._internal.exporters.tail_sampling import TailSamplingOptions as TailSamplingOptions
+from ._internal.main import Logfire as Logfire, LogfireSpan as LogfireSpan
+from ._internal.scrubbing import ScrubMatch as ScrubMatch, ScrubbingOptions as ScrubbingOptions
+from ._internal.utils import suppress_instrumentation as suppress_instrumentation
+from .integrations.logging import LogfireLoggingHandler as LogfireLoggingHandler
+from .integrations.structlog import LogfireProcessor as StructlogProcessor
+from .version import VERSION as VERSION
+
+__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'ConsoleOptions', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'error', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_fastapi', 'instrument_openai', 'instrument_anthropic', 'instrument_asyncpg', 'instrument_httpx', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_aiohttp_client', 'instrument_sqlalchemy', 'instrument_redis', 'instrument_pymongo', 'AutoTraceModule', 'with_tags', 'with_settings', 'shutdown', 'load_spans_from_file', 'no_auto_trace', 'METRICS_PREFERRED_TEMPORALITY', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'TailSamplingOptions']
+
+DEFAULT_LOGFIRE_INSTANCE = Logfire()
+span = DEFAULT_LOGFIRE_INSTANCE.span
+instrument = DEFAULT_LOGFIRE_INSTANCE.instrument
+force_flush = DEFAULT_LOGFIRE_INSTANCE.force_flush
+log_slow_async_callbacks = DEFAULT_LOGFIRE_INSTANCE.log_slow_async_callbacks
+install_auto_tracing = DEFAULT_LOGFIRE_INSTANCE.install_auto_tracing
+instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
+instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
+instrument_anthropic = DEFAULT_LOGFIRE_INSTANCE.instrument_anthropic
+instrument_asyncpg = DEFAULT_LOGFIRE_INSTANCE.instrument_asyncpg
+instrument_httpx = DEFAULT_LOGFIRE_INSTANCE.instrument_httpx
+instrument_requests = DEFAULT_LOGFIRE_INSTANCE.instrument_requests
+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_aiohttp_client = DEFAULT_LOGFIRE_INSTANCE.instrument_aiohttp_client
+instrument_sqlalchemy = DEFAULT_LOGFIRE_INSTANCE.instrument_sqlalchemy
+instrument_redis = DEFAULT_LOGFIRE_INSTANCE.instrument_redis
+instrument_pymongo = DEFAULT_LOGFIRE_INSTANCE.instrument_pymongo
+shutdown = DEFAULT_LOGFIRE_INSTANCE.shutdown
+with_tags = DEFAULT_LOGFIRE_INSTANCE.with_tags
+with_settings = DEFAULT_LOGFIRE_INSTANCE.with_settings
+log = DEFAULT_LOGFIRE_INSTANCE.log
+trace = DEFAULT_LOGFIRE_INSTANCE.trace
+debug = DEFAULT_LOGFIRE_INSTANCE.debug
+info = DEFAULT_LOGFIRE_INSTANCE.info
+notice = DEFAULT_LOGFIRE_INSTANCE.notice
+warn = DEFAULT_LOGFIRE_INSTANCE.warn
+error = DEFAULT_LOGFIRE_INSTANCE.error
+fatal = DEFAULT_LOGFIRE_INSTANCE.fatal
+__version__ = VERSION

logfire_api-0.46.1/logfire_api/_internal/ast_utils.pyi

@@ -0,0 +1,34 @@
+import ast
+from .constants import 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
+from .stack_info import StackInfo as StackInfo, get_filepath_attribute as get_filepath_attribute
+from .utils import uniquify_sequence as uniquify_sequence
+from dataclasses import dataclass
+from opentelemetry.util import types as otel_types
+
+@dataclass(frozen=True)
+class LogfireArgs:
+    """Values passed to `logfire.instrument` and/or values stored in a logfire instance as basic configuration.
+
+    These determine the arguments passed to the method calls added by the AST transformer.
+    """
+    tags: tuple[str, ...]
+    sample_rate: float | None
+    msg_template: str | None = ...
+    span_name: str | None = ...
+    extract_args: bool = ...
+
+@dataclass
+class BaseTransformer(ast.NodeTransformer):
+    """Helper for rewriting ASTs to wrap function bodies in `with {logfire_method_name}(...):`."""
+    logfire_args: LogfireArgs
+    logfire_method_name: str
+    filename: str
+    module_name: str
+    qualname_stack = ...
+    def __post_init__(self) -> None: ...
+    def visit_ClassDef(self, node: ast.ClassDef): ...
+    def visit_FunctionDef(self, node: ast.FunctionDef | ast.AsyncFunctionDef): ...
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef): ...
+    def rewrite_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef, qualname: str) -> ast.AST: ...
+    def logfire_method_call_node(self, node: ast.FunctionDef | ast.AsyncFunctionDef, qualname: str) -> ast.Call: ...
+    def logfire_method_arg_values(self, qualname: str, lineno: int) -> tuple[str, dict[str, otel_types.AttributeValue]]: ...

logfire_api-0.46.1/logfire_api/_internal/async_.pyi

@@ -0,0 +1,22 @@
+from .constants import ONE_SECOND_IN_NANOSECONDS as ONE_SECOND_IN_NANOSECONDS
+from .main import Logfire as Logfire
+from .stack_info import StackInfo as StackInfo, get_code_object_info as get_code_object_info, get_stack_info_from_frame as get_stack_info_from_frame
+from .utils import safe_repr as safe_repr
+from _typeshed import Incomplete
+from types import CoroutineType
+from typing import Any, ContextManager
+
+ASYNCIO_PATH: Incomplete
+
+def log_slow_callbacks(logfire: Logfire, slow_duration: float) -> ContextManager[None]:
+    """Log a warning whenever a function running in the asyncio event loop blocks for too long.
+
+    See Logfire.log_slow_async_callbacks.
+    Inspired by https://gitlab.com/quantlane/libs/aiodebug.
+    """
+
+class _CallbackAttributes(StackInfo, total=False):
+    name: str
+    stack: list[StackInfo]
+
+def stack_info_from_coroutine(coro: CoroutineType[Any, Any, Any]) -> StackInfo: ...

logfire_api-0.46.1/logfire_api/_internal/auth.pyi

@@ -0,0 +1,55 @@
+import requests
+from .utils import UnexpectedResponse as UnexpectedResponse
+from _typeshed import Incomplete
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from typing import TypedDict
+
+HOME_LOGFIRE: Incomplete
+DEFAULT_FILE: Incomplete
+
+class UserTokenData(TypedDict):
+    """User token data."""
+    token: str
+    expiration: str
+
+class DefaultFile(TypedDict):
+    """Content of the default.toml file."""
+    tokens: dict[str, UserTokenData]
+
+class NewDeviceFlow(TypedDict):
+    """Matches model of the same name in the backend."""
+    device_code: str
+    frontend_auth_url: str
+
+def request_device_code(session: requests.Session, base_api_url: str) -> tuple[str, str]:
+    """Request a device code from the Logfire API.
+
+    Args:
+        session: The `requests` session to use.
+        base_api_url: The base URL of the Logfire instance.
+
+    Returns:
+    return data['device_code'], data['frontend_auth_url']
+        The device code and the frontend URL to authenticate the device at, as a `NewDeviceFlow` dict.
+    """
+def poll_for_token(session: requests.Session, device_code: str, base_api_url: str) -> UserTokenData:
+    """Poll the Logfire API for the user token.
+
+    This function will keep polling the API until it receives a user token, not that
+    each request should take ~10 seconds as the API endpoint will block waiting for the user to
+    complete authentication.
+
+    Args:
+        session: The `requests` session to use.
+        device_code: The device code to poll for.
+        base_api_url: The base URL of the Logfire instance.
+
+    Returns:
+        The user token.
+    """
+def is_logged_in(data: DefaultFile, logfire_url: str) -> bool:
+    """Check if the user is logged in.
+
+    Returns:
+        True if the user is logged in, False otherwise.
+    """

logfire_api-0.46.1/logfire_api/_internal/auto_trace/__init__.pyi

@@ -0,0 +1,15 @@
+from ..constants import ONE_SECOND_IN_NANOSECONDS as ONE_SECOND_IN_NANOSECONDS
+from ..main import Logfire as Logfire
+from .import_hook import LogfireFinder as LogfireFinder
+from .types import AutoTraceModule as AutoTraceModule
+from typing import Callable, Literal, Sequence
+
+def install_auto_tracing(logfire: Logfire, modules: Sequence[str] | Callable[[AutoTraceModule], bool], *, check_imported_modules: Literal['error', 'warn', 'ignore'] = 'error', min_duration: float = 0) -> None:
+    """Install automatic tracing.
+
+    See `Logfire.install_auto_tracing` for more information.
+    """
+def modules_func_from_sequence(modules: Sequence[str]) -> Callable[[AutoTraceModule], bool]: ...
+
+class AutoTraceModuleAlreadyImportedException(Exception): ...
+class AutoTraceModuleAlreadyImportedWarning(Warning): ...

logfire_api-0.46.1/logfire_api/_internal/auto_trace/import_hook.pyi

@@ -0,0 +1,38 @@
+from ..main import Logfire as Logfire
+from .rewrite_ast import exec_source as exec_source
+from .types import AutoTraceModule as AutoTraceModule
+from dataclasses import dataclass
+from importlib.abc import Loader, MetaPathFinder
+from importlib.machinery import ModuleSpec
+from types import ModuleType
+from typing import Callable, Sequence
+
+@dataclass
+class LogfireFinder(MetaPathFinder):
+    """The import hook entry point, inserted into `sys.meta_path` to apply AST rewriting to matching modules."""
+    logfire: Logfire
+    modules_filter: Callable[[AutoTraceModule], bool]
+    min_duration: int
+    def find_spec(self, fullname: str, path: Sequence[str] | None, target: ModuleType | None = None) -> ModuleSpec | None:
+        """This is the method that is called by the import system.
+
+        It uses the other existing meta path finders to do most of the standard work,
+        particularly finding the module's source code and filename.
+        If it finds a module spec that matches the filter, it returns a new spec that uses the LogfireLoader.
+        """
+
+@dataclass
+class LogfireLoader(Loader):
+    """An import loader produced by LogfireFinder which executes a modified AST of the module's source code."""
+    plain_spec: ModuleSpec
+    source: str
+    logfire: Logfire
+    min_duration: int
+    def exec_module(self, module: ModuleType):
+        """Execute a modified AST of the module's source code in the module's namespace.
+
+        This is called by the import system.
+        """
+    def create_module(self, spec: ModuleSpec): ...
+    def __getattr__(self, item: str):
+        """Forward some methods to the plain spec's loader (likely a `SourceFileLoader`) if they exist."""

logfire_api-0.46.1/logfire_api/_internal/auto_trace/rewrite_ast.pyi

@@ -0,0 +1,51 @@
+import ast
+from ..ast_utils import BaseTransformer as BaseTransformer, LogfireArgs as LogfireArgs
+from ..main import Logfire as Logfire
+from dataclasses import dataclass
+from typing import Any, Callable, ContextManager, TypeVar
+
+def exec_source(source: str, filename: str, module_name: str, globs: dict[str, Any], logfire_instance: Logfire, min_duration: int) -> None:
+    """Execute a modified AST of the module's source code in the module's namespace.
+
+    The modified AST wraps the body of every function definition in `with context_factories[index]():`.
+    `context_factories` is added to the module's namespace as `logfire_<uuid>`.
+    `index` is a different constant number for each function definition.
+    `context_factories[index]` is one of these:
+        - `partial(logfire_instance._fast_span, name, attributes)` where the name and attributes
+            are constructed from `filename`, `module_name`, attributes of `logfire_instance`,
+            and the qualified name and line number of the current function.
+        - `MeasureTime`, a class that measures the time elapsed. If it exceeds `min_duration`,
+            then `context_factories[index]` is replaced with the `partial` above.
+    If `min_duration` is greater than 0, then `context_factories[index]` is initially `MeasureTime`.
+    Otherwise, it's initially the `partial` above.
+    """
+def rewrite_ast(source: str, filename: str, logfire_name: str, module_name: str, logfire_instance: Logfire, context_factories: list[Callable[[], ContextManager[Any]]], min_duration: int) -> ast.AST: ...
+
+@dataclass
+class AutoTraceTransformer(BaseTransformer):
+    """Trace all encountered functions except those explicitly marked with `@no_auto_trace`."""
+    logfire_instance: Logfire
+    context_factories: list[Callable[[], ContextManager[Any]]]
+    min_duration: int
+    def check_no_auto_trace(self, node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef) -> bool:
+        """Return true if the node has a `@no_auto_trace` or `@logfire.no_auto_trace` decorator."""
+    def visit_ClassDef(self, node: ast.ClassDef): ...
+    def visit_FunctionDef(self, node: ast.FunctionDef | ast.AsyncFunctionDef): ...
+    def logfire_method_call_node(self, node: ast.FunctionDef | ast.AsyncFunctionDef, qualname: str) -> ast.Call: ...
+T = TypeVar('T')
+
+def no_auto_trace(x: T) -> T:
+    """Decorator to prevent a function/class from being traced by `logfire.install_auto_tracing`.
+
+    This is useful for small functions that are called very frequently and would generate too much noise.
+
+    The decorator is detected at import time.
+    Only `@no_auto_trace` or `@logfire.no_auto_trace` are supported.
+    Renaming/aliasing either the function or module won't work.
+    Neither will calling this indirectly via another function.
+
+    Any decorated function, or any function defined anywhere inside a decorated function/class,
+    will be completely ignored by `logfire.install_auto_tracing`.
+
+    This decorator simply returns the argument unchanged, so there is zero runtime overhead.
+    """

logfire_api-0.46.1/logfire_api/_internal/auto_trace/types.pyi

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from typing import Sequence
+
+@dataclass
+class AutoTraceModule:
+    """Information about a module being imported that should maybe be traced automatically.
+
+    This object will be passed to a function that should return True if the module should be traced.
+    In particular it'll be passed to a function that's passed to `install_auto_tracing` as the `modules` argument.
+    """
+    name: str
+    filename: str | None
+    def parts_start_with(self, prefix: str | Sequence[str]) -> bool:
+        """Return True if the module name starts with any of the given prefixes, using dots as boundaries.
+
+        For example, if the module name is `foo.bar.spam`, then `parts_start_with('foo')` will return True,
+        but `parts_start_with('bar')` or `parts_start_with('foo_bar')` will return False.
+        In other words, this will match the module itself or any submodules.
+
+        If a prefix contains any characters other than letters, numbers, and dots,
+        then it will be treated as a regular expression.
+        """
+
+def get_module_pattern(module: str): ...

logfire_api-0.46.1/logfire_api/_internal/backfill.pyi

@@ -0,0 +1,72 @@
+from .constants import LevelName
+from _typeshed import Incomplete
+from datetime import datetime
+from pathlib import Path
+from pydantic import BaseModel
+from typing import Any, IO
+
+__all__ = ['generate_trace_id', 'generate_span_id', 'Log', 'StartSpan', 'PrepareBackfill']
+
+def generate_trace_id() -> int:
+    """Generate a new trace ID.
+
+    Returns:
+        A new trace ID.
+    """
+def generate_span_id() -> int:
+    """Generate a new span ID.
+
+    Returns:
+        A new span ID.
+    """
+
+class Log(BaseModel):
+    """A log record."""
+    model_config = pydantic_config
+    msg_template: str
+    level: LevelName
+    service_name: str
+    attributes: dict[str, Any]
+    trace_id: int
+    span_id: int
+    parent_span_id: int | None
+    timestamp: datetime | None
+    formatted_msg: str | None
+    otel_resource_attributes: dict[str, Any]
+
+class StartSpan(BaseModel):
+    """A span."""
+    model_config = pydantic_config
+    span_name: str
+    msg_template: str
+    service_name: str
+    parent: StartSpan | int | None
+    log_attributes: dict[str, Any]
+    span_id: int
+    trace_id: int
+    parent_span_id: int | None
+    start_timestamp: datetime | None
+    formatted_msg: str | None
+    otel_resource_attributes: dict[str, Any]
+    def end(self, end_timestamp: datetime) -> Span:
+        """End the span at a given timestamp."""
+
+class Span(StartSpan):
+    end_timestamp: datetime | None
+
+class PrepareBackfill:
+    """Prepare a backfill of logfire logs and spans from a file or stream.
+
+    Attributes:
+        store_path: The path to the file or stream to backfill.
+        open_spans: A mapping of open spans, keyed by (trace_id, span_id).
+        processor: The span processor to use for the backfill.
+    """
+    store_path: Incomplete
+    processor: Incomplete
+    scrubber: Incomplete
+    def __init__(self, file: Path | str | IO[bytes], batch: bool = True) -> None: ...
+    def __enter__(self) -> PrepareBackfill: ...
+    def write(self, data: Log | Span) -> None:
+        """Write the data to the backfill."""
+    def __exit__(self, *_: Any) -> None: ...

logfire_api-0.46.1/logfire_api/_internal/cli.pyi

@@ -0,0 +1,48 @@
+import argparse
+from ..version import VERSION as VERSION
+from .auth import DEFAULT_FILE as DEFAULT_FILE, DefaultFile as DefaultFile, HOME_LOGFIRE as HOME_LOGFIRE, is_logged_in as is_logged_in, poll_for_token as poll_for_token, request_device_code as request_device_code
+from .config import LogfireCredentials as LogfireCredentials
+from .config_params import ParamManager as ParamManager
+from .constants import LOGFIRE_BASE_URL as LOGFIRE_BASE_URL
+from .tracer import SDKTracerProvider as SDKTracerProvider
+from .utils import read_toml_file as read_toml_file
+from _typeshed import Incomplete
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from logfire.propagate import ContextCarrier as ContextCarrier, get_context as get_context
+
+BASE_OTEL_INTEGRATION_URL: str
+BASE_DOCS_URL: str
+INTEGRATIONS_DOCS_URL: Incomplete
+LOGFIRE_LOG_FILE: Incomplete
+file_handler: Incomplete
+logger: Incomplete
+
+def version_callback() -> None:
+    """Show the version and exit."""
+def parse_whoami(args: argparse.Namespace) -> None:
+    """Show user authenticated username and the URL to your Logfire project."""
+def parse_clean(args: argparse.Namespace) -> None:
+    """Remove the contents of the Logfire data directory."""
+def parse_backfill(args: argparse.Namespace) -> None:
+    """Bulk upload data to Logfire."""
+
+OTEL_PACKAGES: set[str]
+OTEL_PACKAGE_LINK: Incomplete
+
+def parse_inspect(args: argparse.Namespace) -> None:
+    """Inspect installed packages and recommend packages that might be useful."""
+def parse_auth(args: argparse.Namespace) -> None:
+    """Authenticate with Logfire.
+
+    This will authenticate your machine with Logfire and store the credentials.
+    """
+def parse_list_projects(args: argparse.Namespace) -> None:
+    """List user projects."""
+def parse_create_new_project(args: argparse.Namespace) -> None:
+    """Create a new project."""
+def parse_use_project(args: argparse.Namespace) -> None:
+    """Use an existing project."""
+def parse_info(_args: argparse.Namespace) -> None:
+    """Show versions of logfire, OS and related packages."""
+def main(args: list[str] | None = None) -> None:
+    """Run the CLI."""

logfire_api-0.46.1/logfire_api/_internal/collect_system_info.pyi

@@ -0,0 +1,6 @@
+def collect_package_info() -> dict[str, str]:
+    """Retrieve the package information for all installed packages.
+
+    Returns:
+        A dicts with the package name and version.
+    """