Initial work on managed variables

Author: dmontagu

logfire/_internal/config.py

@@ -67,6 +67,9 @@
 
 from ..propagate import NoExtractTraceContextPropagator, WarnOnExtractTraceContextPropagator
 from ..types import ExceptionCallback
+from ..variables.config import VariablesConfig
+from ..variables.providers.abstract import NoOpVariableProvider, VariableProvider
+from ..variables.providers.local import LogfireLocalProvider
 from .client import InvalidProjectName, LogfireClient, ProjectAlreadyExists
 from .config_params import ParamManager, PydanticPluginRecordValues
 from .constants import (
@@ -258,6 +261,44 @@ class CodeSource:
     """
 
 
+@dataclass(init=False)
+class VariablesOptions:
+    """Configuration of managed variables."""
+
+    provider: VariableProvider
+    include_resource_attributes_in_context: bool = True
+    include_baggage_in_context: bool = True
+
+    def __init__(
+        self,
+        provider: VariableProvider | VariablesConfig | None = None,
+        include_resource_attributes_in_context: bool = True,
+        include_baggage_in_context: bool = True,
+    ):
+        if isinstance(provider, VariablesConfig):
+            provider = LogfireLocalProvider(provider)
+        elif not provider:
+            provider = NoOpVariableProvider()
+
+        self.provider = provider
+        self.include_resource_attributes_in_context = include_resource_attributes_in_context
+        self.include_baggage_in_context = include_baggage_in_context
+
+    # """Provider for resolving values of Variables.
+    #
+    # Defaults to setting an OFREP-compatible provider that hits Logfire's API."""
+    #
+    # create_remote_spans: bool = True
+    # """Whether to insert OTel spans for variable resolution when using the Logfire OFREP provider.
+    #
+    # Has no impact if using a non-Logfire provider."""
+    #
+    # create_local_spans: bool | None = None
+    # """Whether to open OTel spans for variable resolution in the process.
+    #
+    # Defaults to True if using a non-Logfire provider, otherwise False."""
+
+
 class DeprecatedKwargs(TypedDict):
     # Empty so that passing any additional kwargs makes static type checkers complain.
     pass
@@ -282,6 +323,7 @@ def configure(  # noqa: D417
     min_level: int | LevelName | None = None,
     add_baggage_to_attributes: bool = True,
     code_source: CodeSource | None = None,
+    variables: VariablesOptions | None = None,
     distributed_tracing: bool | None = None,
     advanced: AdvancedOptions | None = None,
     **deprecated_kwargs: Unpack[DeprecatedKwargs],
@@ -346,6 +388,7 @@ def configure(  # noqa: D417
         add_baggage_to_attributes: Set to `False` to prevent OpenTelemetry Baggage from being added to spans as attributes.
             See the [Baggage documentation](https://logfire.pydantic.dev/docs/reference/advanced/baggage/) for more details.
         code_source: Settings for the source code of the project.
+        variables: Options related to managed variables.
         distributed_tracing: By default, incoming trace context is extracted, but generates a warning.
             Set to `True` to disable the warning.
             Set to `False` to suppress extraction of incoming trace context.
@@ -482,6 +525,7 @@ def configure(  # noqa: D417
         sampling=sampling,
         add_baggage_to_attributes=add_baggage_to_attributes,
         code_source=code_source,
+        variables=variables,
         distributed_tracing=distributed_tracing,
         advanced=advanced,
     )
@@ -546,6 +590,9 @@ class _LogfireConfigData:
     code_source: CodeSource | None
     """Settings for the source code of the project."""
 
+    variables: VariablesOptions
+    """Settings related to managed variables."""
+
     distributed_tracing: bool | None
     """Whether to extract incoming trace context."""
 
@@ -573,6 +620,7 @@ def _load_configuration(
         min_level: int | LevelName | None,
         add_baggage_to_attributes: bool,
         code_source: CodeSource | None,
+        variables: VariablesOptions | None,
         distributed_tracing: bool | None,
         advanced: AdvancedOptions | None,
     ) -> None:
@@ -639,6 +687,8 @@ def _load_configuration(
             code_source = CodeSource(**code_source)  # type: ignore
         self.code_source = code_source
 
+        self.variables = variables or VariablesOptions()
+
         if isinstance(advanced, dict):
             # This is particularly for deserializing from a dict as in executors.py
             advanced = AdvancedOptions(**advanced)  # type: ignore
@@ -682,6 +732,7 @@ def __init__(
         sampling: SamplingOptions | None = None,
         min_level: int | LevelName | None = None,
         add_baggage_to_attributes: bool = True,
+        variables: VariablesOptions | None = None,
         code_source: CodeSource | None = None,
         distributed_tracing: bool | None = None,
         advanced: AdvancedOptions | None = None,
@@ -711,6 +762,7 @@ def __init__(
             min_level=min_level,
             add_baggage_to_attributes=add_baggage_to_attributes,
             code_source=code_source,
+            variables=variables,
             distributed_tracing=distributed_tracing,
             advanced=advanced,
         )
@@ -720,6 +772,7 @@ def __init__(
         # note: this reference is important because the MeterProvider runs things in background threads
         # thus it "shuts down" when it's gc'ed
         self._meter_provider = ProxyMeterProvider(NoOpMeterProvider())
+        self._variable_provider = NoOpVariableProvider()
         self._logger_provider = ProxyLoggerProvider(NoOpLoggerProvider())
         try:
             from opentelemetry.sdk._events import EventLoggerProvider as SDKEventLoggerProvider
@@ -750,6 +803,7 @@ def configure(
         min_level: int | LevelName | None,
         add_baggage_to_attributes: bool,
         code_source: CodeSource | None,
+        variables: VariablesOptions | None,
         distributed_tracing: bool | None,
         advanced: AdvancedOptions | None,
     ) -> None:
@@ -772,6 +826,7 @@ def configure(
                 min_level,
                 add_baggage_to_attributes,
                 code_source,
+                variables,
                 distributed_tracing,
                 advanced,
             )
@@ -1103,6 +1158,9 @@ def fix_pid():  # pragma: no cover
             )  # note: this may raise an Exception if it times out, call `logfire.shutdown` first
             self._meter_provider.set_meter_provider(meter_provider)
 
+            self._variable_provider.shutdown()
+            self._variable_provider = self.variables.provider
+
             multi_log_processor = SynchronousMultiLogRecordProcessor()
             for processor in log_record_processors:
                 multi_log_processor.add_log_record_processor(processor)

logfire/_internal/main.py

@@ -5,7 +5,7 @@
 import json
 import sys
 import warnings
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Mapping, Sequence
 from contextlib import AbstractContextManager
 from contextvars import Token
 from enum import Enum
@@ -30,6 +30,7 @@
 from opentelemetry.util import types as otel_types
 from typing_extensions import LiteralString, ParamSpec
 
+from ..variables.variable import ResolveFunction, Variable
 from ..version import VERSION
 from . import async_
 from .auto_trace import AutoTraceModule, install_auto_tracing
@@ -125,6 +126,8 @@
     # 3. The argument name exc_info is very suggestive of the sys function.
     ExcInfo = Union[SysExcInfo, BaseException, bool, None]
 
+T = TypeVar('T')
+
 
 class Logfire:
     """The main logfire class."""
@@ -148,6 +151,10 @@ def __init__(
     def config(self) -> LogfireConfig:
         return self._config
 
+    @property
+    def resource_attributes(self) -> Mapping[str, Any]:
+        return self._tracer_provider.resource.attributes
+
     @cached_property
     def _tracer_provider(self) -> ProxyTracerProvider:
         self._config.warn_if_not_initialized('No logs or spans will be created')
@@ -2329,8 +2336,23 @@ def shutdown(self, timeout_millis: int = 30_000, flush: bool = True) -> bool:  #
         if not remaining:  # pragma: no cover
             return False
         self._meter_provider.shutdown(remaining)
+
+        remaining = max(0, timeout_millis - (time() - start))
+        if not remaining:  # pragma: no cover
+            return False
+
+        self.config.variables.provider.shutdown()
+
         return (start - time()) < timeout_millis
 
+    def var(self, *, name: str, default: T | ResolveFunction[T], type: type[T] | Sequence[type[T]]) -> Variable[T]:
+        tp: type[T]
+        if isinstance(type, Sequence):
+            tp = Union[tuple(type)]  # pyright: ignore[reportAssignmentType]
+        else:
+            tp = type
+        return Variable[T](name, default=default, type=tp, logfire_instance=self)
+
 
 class FastLogfireSpan:
     """A simple version of `LogfireSpan` optimized for auto-tracing."""

logfire/variables/__init__.py

@@ -0,0 +1,8 @@
+from importlib.util import find_spec
+
+if not find_spec('pydantic'):
+    raise RuntimeError(
+        'The `logfire.variables` module requires the `pydantic` package.\n'
+        'You can install this with:\n'
+        "    pip install 'logfire[variables]'"
+    )