Release v4.4.0 (#1377)

Author: alexmojaki

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Release Notes
 
+## [v4.4.0] (2025-09-05)
+
+* Add `logfire.instrument_print()` by @alexmojaki in [#1368](https://github.com/pydantic/logfire/pull/1368)
+* Record response on 'MCP server handle request' span by @alexmojaki in [#1362](https://github.com/pydantic/logfire/pull/1362)
+* Handle MCP request metadata being a dict by @alexmojaki in [#1360](https://github.com/pydantic/logfire/pull/1360)
+* fix: handle optional args in `logfire.instrument` by @stevenh in [#1337](https://github.com/pydantic/logfire/pull/1337)
+* Add `logfire_token` to scrubbing patterns by @alexmojaki in [#1367](https://github.com/pydantic/logfire/pull/1367)
+
 ## [v4.3.6] (2025-08-26)
 
 * Add specific code agent options for `logfire prompt` by @Kludex in [#1350](https://github.com/pydantic/logfire/pull/1350)
@@ -871,3 +879,4 @@ First release from new repo!
 [v4.3.4]: https://github.com/pydantic/logfire/compare/v4.3.3...v4.3.4
 [v4.3.5]: https://github.com/pydantic/logfire/compare/v4.3.4...v4.3.5
 [v4.3.6]: https://github.com/pydantic/logfire/compare/v4.3.5...v4.3.6
+[v4.4.0]: https://github.com/pydantic/logfire/compare/v4.3.6...v4.4.0

logfire-api/logfire_api/__init__.pyi

@@ -14,7 +14,7 @@ from .version import VERSION as VERSION
 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_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_system_metrics', 'instrument_mcp', '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', 'logfire_info', 'get_baggage', 'set_baggage']
+__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_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_system_metrics', 'instrument_mcp', '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', 'logfire_info', 'get_baggage', 'set_baggage']
 
 DEFAULT_LOGFIRE_INSTANCE = Logfire()
 span = DEFAULT_LOGFIRE_INSTANCE.span
@@ -32,6 +32,7 @@ instrument_openai_agents = DEFAULT_LOGFIRE_INSTANCE.instrument_openai_agents
 instrument_anthropic = DEFAULT_LOGFIRE_INSTANCE.instrument_anthropic
 instrument_google_genai = DEFAULT_LOGFIRE_INSTANCE.instrument_google_genai
 instrument_litellm = DEFAULT_LOGFIRE_INSTANCE.instrument_litellm
+instrument_print = DEFAULT_LOGFIRE_INSTANCE.instrument_print
 instrument_asyncpg = DEFAULT_LOGFIRE_INSTANCE.instrument_asyncpg
 instrument_httpx = DEFAULT_LOGFIRE_INSTANCE.instrument_httpx
 instrument_celery = DEFAULT_LOGFIRE_INSTANCE.instrument_celery

logfire-api/logfire_api/_internal/ast_utils.pyi

@@ -1,7 +1,12 @@
 import ast
+import executing
+import types
 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 _typeshed import Incomplete
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
 from dataclasses import dataclass
 from opentelemetry.util import types as otel_types
 
@@ -31,3 +36,43 @@ class BaseTransformer(ast.NodeTransformer):
     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]]: ...
+
+class CallNodeFinder(ABC):
+    """Base class for finding the `ast.Call` node corresponding to a function call in a given frame.
+
+    Uses `executing`, then falls back to a heuristic if that fails.
+    The heuristic is defined by subclasses which depends on what we're looking for,
+    but in general `executing` is expected to work.
+    Warns appropriately when things don't work.
+    Only used when `inspect_arguments=True` in `logfire.configure()`.
+    """
+    frame: Incomplete
+    ex: Incomplete
+    source: Incomplete
+    node: Incomplete
+    def __init__(self, frame: types.FrameType) -> None: ...
+    @abstractmethod
+    def heuristic_main_nodes(self) -> Iterator[ast.AST]:
+        """AST nodes (e.g. statements) to search for potential call nodes inside."""
+    @abstractmethod
+    def heuristic_call_node_filter(self, node: ast.Call) -> bool:
+        """Condition that a potential call node must satisfy to be considered a match."""
+    @abstractmethod
+    def warn_inspect_arguments_middle(self) -> str:
+        """Middle part of the warning message for `warn_inspect_arguments`.
+
+        Should describe the consequences of the failure.
+        """
+    def warn_inspect_arguments(self, msg: str): ...
+    def get_stacklevel(self): ...
+
+class InspectArgumentsFailedWarning(Warning): ...
+
+def get_node_source_text(node: ast.AST, ex_source: executing.Source):
+    """Returns some Python source code representing `node`.
+
+    Preferably the actual original code given by `ast.get_source_segment`,
+    but falling back to `ast.unparse(node)` if the former is incorrect.
+    This happens sometimes due to Python bugs (especially for older Python versions)
+    in the source positions of AST nodes inside f-strings.
+    """

logfire-api/logfire_api/_internal/config.pyi

@@ -135,6 +135,8 @@ def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-
 
             Defaults to `True` if and only if the Python version is at least 3.11.
 
+            Also enables magic argument inspection in [`logfire.instrument_print()`][logfire.Logfire.instrument_print].
+
         min_level:
             Minimum log level for logs and spans to be created. By default, all logs and spans are created.
             For example, set to 'info' to only create logs with level 'info' or higher, thus filtering out debug logs.

logfire-api/logfire_api/_internal/formatter.pyi

@@ -1,11 +1,12 @@
 import ast
 import executing
 import types
-from .constants import ATTRIBUTES_SCRUBBED_KEY as ATTRIBUTES_SCRUBBED_KEY, MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT as MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT
-from .scrubbing import BaseScrubber as BaseScrubber, NOOP_SCRUBBER as NOOP_SCRUBBER, ScrubbedNote as ScrubbedNote
+from .ast_utils import CallNodeFinder as CallNodeFinder, get_node_source_text as get_node_source_text
+from .scrubbing import BaseScrubber as BaseScrubber, MessageValueCleaner as MessageValueCleaner, NOOP_SCRUBBER as NOOP_SCRUBBER
 from .stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
-from .utils import log_internal_error as log_internal_error, truncate_string as truncate_string
+from .utils import log_internal_error as log_internal_error
 from _typeshed import Incomplete
+from collections.abc import Iterator
 from functools import lru_cache
 from string import Formatter
 from types import CodeType as CodeType
@@ -36,19 +37,6 @@ def compile_formatted_value(node: ast.FormattedValue, ex_source: executing.Sourc
     2. A compiled code object which can be evaluated to calculate the value.
     3. Another code object which formats the value.
     """
-def get_node_source_text(node: ast.AST, ex_source: executing.Source):
-    """Returns some Python source code representing `node`.
-
-    Preferably the actual original code given by `ast.get_source_segment`,
-    but falling back to `ast.unparse(node)` if the former is incorrect.
-    This happens sometimes due to Python bugs (especially for older Python versions)
-    in the source positions of AST nodes inside f-strings.
-    """
-def get_stacklevel(frame: types.FrameType): ...
-
-class InspectArgumentsFailedWarning(Warning): ...
-
-def warn_inspect_arguments(msg: str, stacklevel: int): ...
 
 class KnownFormattingError(Exception):
     """An error raised when there's something wrong with a format string or the field values.
@@ -66,3 +54,9 @@ class FormattingFailedWarning(UserWarning): ...
 
 def warn_formatting(msg: str): ...
 def warn_fstring_await(msg: str): ...
+
+class FormattingCallNodeFinder(CallNodeFinder):
+    """Finds the call node corresponding to a call like `logfire.span` or `logfire.info`."""
+    def heuristic_main_nodes(self) -> Iterator[ast.AST]: ...
+    def heuristic_call_node_filter(self, node: ast.Call) -> bool: ...
+    def warn_inspect_arguments_middle(self): ...

logfire-api/logfire_api/_internal/integrations/mcp.pyi

@@ -1,5 +1,7 @@
 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
 
 def instrument_mcp(logfire_instance: Logfire, propagate_otel_context: bool): ...

logfire-api/logfire_api/_internal/integrations/print.pyi

@@ -0,0 +1,29 @@
+import ast
+from collections.abc import Iterator
+from contextlib import AbstractContextManager
+from logfire import Logfire as Logfire
+from logfire._internal.ast_utils import CallNodeFinder as CallNodeFinder, get_node_source_text as get_node_source_text
+from logfire._internal.constants import ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY
+from logfire._internal.scrubbing import MessageValueCleaner as MessageValueCleaner
+from logfire._internal.utils import handle_internal_errors as handle_internal_errors
+from typing import Any
+
+FALLBACK_ATTRIBUTE_KEY: str
+
+def instrument_print(logfire_instance: Logfire) -> AbstractContextManager[None]:
+    """Instruments the built-in `print` function to send logs to **Logfire**.
+
+    See Logfire.instrument_print for full documentation.
+    """
+
+class PrintCallNodeFinder(CallNodeFinder):
+    def heuristic_main_nodes(self) -> Iterator[ast.AST]: ...
+    def heuristic_call_node_filter(self, node: ast.Call) -> bool: ...
+    def warn_inspect_arguments_middle(self): ...
+    def get_magic_attributes(self, args: tuple[Any, ...], value_cleaner: MessageValueCleaner) -> tuple[dict[str, Any], list[str]]:
+        """Inspects argument expression AST nodes.
+
+        Returns:
+            - An attributes dict mapping non-literal argument expressions sources to their runtime values.
+            - A list of strings to construct the log message.
+        """

logfire-api/logfire_api/_internal/main.pyi

@@ -582,6 +582,24 @@ class Logfire:
         """
     def instrument_google_genai(self) -> None: ...
     def instrument_litellm(self, **kwargs: Any): ...
+    def instrument_print(self) -> AbstractContextManager[None]:
+        """Instrument the built-in `print` function so that calls to it are logged.
+
+        If Logfire is configured with [`inspect_arguments=True`][logfire.configure(inspect_arguments)],
+        the names of the arguments passed to `print` will be included in the log attributes
+        and will be used for scrubbing.
+
+        The fallback attribute name `logfire.print_args` will be used if:
+
+         - `inspect_arguments` is `False`
+         - Inspection fails for any reason
+         - Multiple starred arguments are used (e.g. `print(*args1, *args2)`)
+            in which case names can't be unambiguously determined.
+
+        Returns:
+            A context manager that will revert the instrumentation when exited.
+                Use of this context manager is optional.
+        """
     def instrument_asyncpg(self, **kwargs: Any) -> None:
         """Instrument the `asyncpg` module so that spans are automatically created for each query."""
     @overload

logfire-api/logfire_api/_internal/scrubbing.pyi

@@ -1,8 +1,8 @@
 import re
 import typing_extensions
-from .constants import ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_LOG_LEVEL_NAME_KEY as ATTRIBUTES_LOG_LEVEL_NAME_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_PENDING_SPAN_REAL_PARENT_KEY as ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SCRUBBED_KEY as ATTRIBUTES_SCRUBBED_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, RESOURCE_ATTRIBUTES_PACKAGE_VERSIONS as RESOURCE_ATTRIBUTES_PACKAGE_VERSIONS
+from .constants import ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_LOG_LEVEL_NAME_KEY as ATTRIBUTES_LOG_LEVEL_NAME_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_PENDING_SPAN_REAL_PARENT_KEY as ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SCRUBBED_KEY as ATTRIBUTES_SCRUBBED_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT as MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT, RESOURCE_ATTRIBUTES_PACKAGE_VERSIONS as RESOURCE_ATTRIBUTES_PACKAGE_VERSIONS
 from .stack_info import STACK_INFO_KEYS as STACK_INFO_KEYS
-from .utils import ReadableSpanDict as ReadableSpanDict
+from .utils import ReadableSpanDict as ReadableSpanDict, truncate_string as truncate_string
 from _typeshed import Incomplete
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
@@ -73,3 +73,27 @@ class SpanScrubber:
         `path` is a list of keys and indices leading to `value` in the span.
         Similar to the truncation code, it should use the field names in the frontend, e.g. `otel_events`.
         """
+
+class MessageValueCleaner:
+    """Scrubs and truncates formatted field values to be included in the message attribute.
+
+    Use to construct the message for a single span, e.g:
+
+        cleaner = MessageValueCleaner(scrubber, check_keys=...)
+        message_parts = [cleaner.clean_value(field_name, str(value)) for field_name, value in fields]
+        message = <construct from message parts>
+        attributes = {**other_attributes, **cleaner.extra_attrs(), ATTRIBUTES_MESSAGE_KEY: message}
+
+    check_keys determines whether the key should be accounted for in scrubbing.
+    Set to False if the user explicitly provided the key, e.g. `logfire.info(f'... {password} ...')`
+    means that the password is clearly expected to be logged.
+    The password will therefore not be scrubbed here and will appear in the message.
+    However it may still be scrubbed out of the attributes, just because that process is independent.
+    """
+    scrubber: Incomplete
+    scrubbed: list[ScrubbedNote]
+    check_keys: Incomplete
+    def __init__(self, scrubber: BaseScrubber, *, check_keys: bool) -> None: ...
+    def clean_value(self, field_name: str, value: str) -> str: ...
+    def truncate(self, value: str) -> str: ...
+    def extra_attrs(self) -> dict[str, Any]: ...

logfire-api/pyproject.toml

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