Initial work on managed variables

logfire-api/logfire_api/__init__.py

@@ -199,6 +199,12 @@ def instrument_mcp(self, *args, **kwargs) -> None: ...
 
             def shutdown(self, *args, **kwargs) -> None: ...
 
+            def var(self, *args, **kwargs):
+                return MagicMock()
+
+            def get_variables(self, *args, **kwargs) -> list[Any]:
+                return []
+
         DEFAULT_LOGFIRE_INSTANCE = Logfire()
         span = DEFAULT_LOGFIRE_INSTANCE.span
         log = DEFAULT_LOGFIRE_INSTANCE.log
@@ -248,6 +254,14 @@ def shutdown(self, *args, **kwargs) -> None: ...
         instrument_mcp = DEFAULT_LOGFIRE_INSTANCE.instrument_mcp
         shutdown = DEFAULT_LOGFIRE_INSTANCE.shutdown
         suppress_scopes = DEFAULT_LOGFIRE_INSTANCE.suppress_scopes
+        var = DEFAULT_LOGFIRE_INSTANCE.var
+        get_variables = DEFAULT_LOGFIRE_INSTANCE.get_variables
+
+        def push_variables(*args, **kwargs) -> bool:
+            return False
+
+        def validate_variables(*args, **kwargs) -> bool:
+            return True
 
         def loguru_handler() -> dict[str, Any]:
             return {}
@@ -279,6 +293,9 @@ def __init__(self, *args, **kwargs) -> None: ...
         class MetricsOptions:
             def __init__(self, *args, **kwargs) -> None: ...
 
+        class VariablesOptions:
+            def __init__(self, *args, **kwargs) -> None: ...
+
         class PydanticPlugin:
             def __init__(self, *args, **kwargs) -> None: ...
 

logfire/__init__.py

@@ -11,14 +11,23 @@
 from ._internal.auto_trace.rewrite_ast import no_auto_trace
 from ._internal.baggage import get_baggage, set_baggage
 from ._internal.cli import logfire_info
-from ._internal.config import AdvancedOptions, CodeSource, ConsoleOptions, MetricsOptions, PydanticPlugin, configure
+from ._internal.config import (
+    AdvancedOptions,
+    CodeSource,
+    ConsoleOptions,
+    MetricsOptions,
+    PydanticPlugin,
+    VariablesOptions,
+    configure,
+)
 from ._internal.constants import LevelName
 from ._internal.main import Logfire, LogfireSpan
 from ._internal.scrubbing import ScrubbingOptions, ScrubMatch
 from ._internal.stack_info import add_non_user_code_prefix
 from ._internal.utils import suppress_instrumentation
 from .integrations.logging import LogfireLoggingHandler
 from .integrations.structlog import LogfireProcessor as StructlogProcessor
+from .variables.push import push_variables, validate_variables
 from .version import VERSION
 
 DEFAULT_LOGFIRE_INSTANCE: Logfire = Logfire()
@@ -83,6 +92,10 @@
 metric_gauge_callback = DEFAULT_LOGFIRE_INSTANCE.metric_gauge_callback
 metric_up_down_counter_callback = DEFAULT_LOGFIRE_INSTANCE.metric_up_down_counter_callback
 
+# Variables
+var = DEFAULT_LOGFIRE_INSTANCE.var
+get_variables = DEFAULT_LOGFIRE_INSTANCE.get_variables
+
 
 def loguru_handler() -> Any:
     """Create a **Logfire** handler for Loguru.
@@ -167,6 +180,11 @@ def loguru_handler() -> Any:
     'loguru_handler',
     'SamplingOptions',
     'MetricsOptions',
+    'VariablesOptions',
+    'var',
+    'get_variables',
+    'push_variables',
+    'validate_variables',
     'logfire_info',
     'get_baggage',
     'set_baggage',

logfire/_internal/client.py

@@ -67,6 +67,17 @@ def _post_raw(self, endpoint: str, body: Any | None = None) -> Response:
         UnexpectedResponse.raise_for_status(response)
         return response
 
+    def _put_raw(self, endpoint: str, body: Any | None = None) -> Response:
+        response = self._session.put(urljoin(self.base_url, endpoint), json=body)
+        UnexpectedResponse.raise_for_status(response)
+        return response
+
+    def _put(self, endpoint: str, *, body: Any | None = None, error_message: str) -> Any:
+        try:
+            return self._put_raw(endpoint, body).json()
+        except UnexpectedResponse as e:
+            raise LogfireConfigError(error_message) from e
+
     def _post(self, endpoint: str, *, body: Any | None = None, error_message: str) -> Any:
         try:
             return self._post_raw(endpoint, body).json()
@@ -133,3 +144,37 @@ def get_prompt(self, organization: str, project_name: str, issue: str) -> dict[s
             params={'issue': issue},
             error_message='Error retrieving prompt',
         )
+
+    # --- Variables API ---
+
+    def get_variables_config(self, organization: str, project_name: str) -> dict[str, Any]:
+        """Get the variables configuration for a project."""
+        return self._get(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/config/',
+            error_message='Error retrieving variables configuration',
+        )
+
+    def get_variable_by_name(self, organization: str, project_name: str, variable_name: str) -> dict[str, Any]:
+        """Get a variable definition by name."""
+        return self._get(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/by-name/{variable_name}/',
+            error_message=f'Error retrieving variable {variable_name!r}',
+        )
+
+    def create_variable(self, organization: str, project_name: str, body: dict[str, Any]) -> dict[str, Any]:
+        """Create a new variable definition."""
+        return self._post(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/',
+            body=body,
+            error_message='Error creating variable',
+        )
+
+    def update_variable(
+        self, organization: str, project_name: str, variable_id: str, body: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Update an existing variable definition."""
+        return self._put(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/{variable_id}/',
+            body=body,
+            error_message='Error updating variable',
+        )

logfire/_internal/config.py

@@ -12,6 +12,7 @@
 from collections.abc import Sequence
 from contextlib import suppress
 from dataclasses import dataclass, field
+from datetime import timedelta
 from pathlib import Path
 from threading import RLock, Thread
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Literal, TypedDict
@@ -63,6 +64,7 @@
 from logfire.exceptions import LogfireConfigError
 from logfire.sampling import SamplingOptions
 from logfire.sampling._tail_sampling import TailSamplingProcessor
+from logfire.variables.abstract import NoOpVariableProvider, VariableProvider
 from logfire.version import VERSION
 
 from ..propagate import NoExtractTraceContextPropagator, WarnOnExtractTraceContextPropagator
@@ -115,6 +117,8 @@
 if TYPE_CHECKING:
     from typing import TextIO
 
+    from logfire.variables import VariablesConfig
+
     from .main import Logfire
 
 
@@ -301,6 +305,28 @@ class CodeSource:
     """
 
 
+@dataclass
+class RemoteVariablesConfig:
+    block_before_first_resolve: bool = True
+    """Whether the remote variables should be fetched before first resolving a value."""
+    polling_interval: timedelta | float = timedelta(seconds=30)
+    """The time interval for polling for updates to the variables config."""
+
+
+@dataclass
+class VariablesOptions:
+    """Configuration of managed variables."""
+
+    config: VariablesConfig | RemoteVariablesConfig | VariableProvider | None = None
+    """A local or remote variables config, or an arbitrary variable provider."""
+    include_resource_attributes_in_context: bool = True
+    """Whether to include OpenTelemetry resource attributes when resolving variables."""
+    include_baggage_in_context: bool = True
+    """Whether to include OpenTelemetry baggage when resolving variables."""
+
+    # TODO: Add OTel-related config here
+
+
 class DeprecatedKwargs(TypedDict):
     # Empty so that passing any additional kwargs makes static type checkers complain.
     pass
@@ -325,6 +351,7 @@ def configure(
     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],
@@ -389,6 +416,7 @@ def configure(
         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.
@@ -525,6 +553,7 @@ def configure(
         sampling=sampling,
         add_baggage_to_attributes=add_baggage_to_attributes,
         code_source=code_source,
+        variables=variables,
         distributed_tracing=distributed_tracing,
         advanced=advanced,
     )
@@ -589,6 +618,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."""
 
@@ -616,6 +648,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:
@@ -682,6 +715,13 @@ def _load_configuration(
             code_source = CodeSource(**code_source)  # type: ignore
         self.code_source = code_source
 
+        if isinstance(variables, dict):
+            # This is particularly for deserializing from a dict as in executors.py
+            variables = VariablesOptions(**variables)  # type: ignore
+        elif variables is None:
+            variables = VariablesOptions()
+        self.variables = variables
+
         if isinstance(advanced, dict):
             # This is particularly for deserializing from a dict as in executors.py
             advanced = AdvancedOptions(**advanced)  # type: ignore
@@ -725,6 +765,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,
@@ -754,6 +795,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,
         )
@@ -763,6 +805,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: VariableProvider = NoOpVariableProvider()
         self._logger_provider = ProxyLoggerProvider(NoOpLoggerProvider())
         # This ensures that we only call OTEL's global set_tracer_provider once to avoid warnings.
         self._has_set_providers = False
@@ -787,6 +830,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:
@@ -809,6 +853,7 @@ def configure(
                 min_level,
                 add_baggage_to_attributes,
                 code_source,
+                variables,
                 distributed_tracing,
                 advanced,
             )
@@ -1121,6 +1166,29 @@ 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)
 
+            from logfire.variables import LocalVariableProvider, LogfireRemoteVariableProvider, VariablesConfig
+
+            self._variable_provider.shutdown()
+            if isinstance(self.variables.config, VariableProvider):
+                self._variable_provider = self.variables.config
+            elif isinstance(self.variables.config, VariablesConfig):
+                self._variable_provider = LocalVariableProvider(self.variables.config)
+            elif isinstance(self.variables.config, RemoteVariablesConfig):
+                # TODO: Need to use a non-write-token
+                token = self.token
+                if token:
+                    base_url = self.advanced.base_url or get_base_url_from_token(token)
+                    self._variable_provider = LogfireRemoteVariableProvider(
+                        base_url=base_url,
+                        token=token,
+                        config=self.variables.config,
+                    )
+                else:
+                    # No token, so can't use the remote variable provider
+                    self._variable_provider = NoOpVariableProvider()
+            elif self.variables.config is None:
+                self._variable_provider = NoOpVariableProvider()
+
             multi_log_processor = SynchronousMultiLogRecordProcessor()
             for processor in log_record_processors:
                 multi_log_processor.add_log_record_processor(processor)
@@ -1231,6 +1299,16 @@ def get_logger_provider(self) -> ProxyLoggerProvider:
         """
         return self._logger_provider
 
+    def get_variable_provider(self) -> VariableProvider:
+        """Get a variable provider from this `LogfireConfig`.
+
+        This is used internally and should not be called by users of the SDK.
+
+        Returns:
+            The variable provider.
+        """
+        return self._variable_provider
+
     def warn_if_not_initialized(self, message: str):
         ignore_no_config_env = os.getenv('LOGFIRE_IGNORE_NO_CONFIG', '')
         ignore_no_config = ignore_no_config_env.lower() in ('1', 'true', 't') or self.ignore_no_config