]jBSSKJr SSKrSSKJs Jr SSKrSSK r SSK r SSK r SSK r SSK JrJrJr SSKJr SSKJr SSKJr SSKJrJr SSKJr SS KJrJrJrJrJrJ r J!r!J"r"J#r# SSK$J%r& SSK'J(r) SS K$J*r* SS K+J,r,J-r-J.r.J/r/ SS K0J1r1J2r2 SS K'J3r3J4r4 SSK5J6r7 SSK8J9r9J:r: SSK;Jr> SSK?J@r@JArA SSKBJCrCJDrD SSKEJFrF SSKGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrS SSKTJUrUJVrV SSKWJWrW SSKXJYrY SSKZJ[r[J\r\J]r]J^r^ SSK_J`r` SSKaJbrb SSKcJdrdJereJfrfJgrg SSKhJiriJjrjJkrkJlrl \(Ga SS K6Jmrm SS!KnJoro SSKprpSSKqrqSSKrrrSSKsrtSSKuruSS"KvJwrwJxrx SS#KyJzrz SS$K{J|r| SS%K}J~r~JrJr SS&K+Jr SS'KJr SS(KJrJrJr SS)KJr SS*KJr SS+KJr SS,KJr SS-KJr SS.KJr SS/KJr SS0K8Jr SS1KJrJr SS2KJrJrJr SS3KJrJrJrJr SS4KJr SS1KJrJr SS4KJr SS1KJrJr SS5KJrJrJrJr SS6KJrJr SS7KJrJr SS8KJr SS9KJr SS:KJrJr SS;KJr SS5r"S?S@5r"SASB5r"SCSD\15r"SESF5r\ "SG\!\\7GR4SH9rSNSIjrSOSJjrSPSKjr\:"SL5r\ "SM5rg)Q) annotationsN)IterableMappingSequence)AbstractContextManager)Token)Enum)cached_propertypartial)time) TYPE_CHECKINGAnyCallableLiteralTypeTypeVarUnioncastoverload)Context) CallbackTCounter Histogram UpDownCounter) ReadableSpanSpan) SpanContextSpanKind)types) LiteralString ParamSpec)VERSION)async_)AutoTraceModuleinstall_auto_tracing) GLOBAL_CONFIG LogfireConfig)PydanticPluginRecordValues) ATTRIBUTES_JSON_SCHEMA_KEYATTRIBUTES_LOG_LEVEL_NUM_KEYATTRIBUTES_MESSAGE_KEYATTRIBUTES_MESSAGE_TEMPLATE_KEYATTRIBUTES_SAMPLE_RATE_KEYATTRIBUTES_SPAN_TYPE_KEYATTRIBUTES_TAGS_KEYDISABLE_CONSOLE_KEY LEVEL_NUMBERSOTLP_MAX_INT_SIZE LevelNamelog_level_attributes)logfire_formatlogfire_format_with_magic) instrument)logfire_json_dumps)JsonSchemaPropertiesattributes_json_schema!attributes_json_schema_propertiescreate_json_schema)ProxyMeterProvider)get_user_stack_info)ProxyTracerProvider_LogfireWrappedSpan _ProxyTracerset_exception_status) get_versionhandle_internal_errorslog_internal_erroruniquify_sequence) ModuleType)WSGIApplication) HttpRequest HttpResponse)FastAPI)Flask)ClientRequestHookClientResponseHookServerRequestHook)_Gauge)EvaluationReport)CommandFailedEventCommandStartedEventCommandSucceededEvent)Engine) AsyncEngine) Starlette)Request) WebSocket) AsyncTemplate) SyncTemplate)Unpack) RequestHook ResponseHook)CommenterOptionsr_r`)AsyncRequestHookAsyncResponseHookr_r`)ra)ResolveFunctionValidationReportVariableVariablesConfig)ASGIAppASGIInstrumentKwargs) LambdaEvent LambdaHandler)SemconvVersion)MySQLConnection)Psycopg2ConnectionPsycopgConnection)SQLite3Connection)BaseConfig) SysExcInfoTc  \rSrSrSr\SSSSS.S|Sjjr\S}S j5r\S~S j5r \ SS j5r \ SS j5r \ S 5r \ SSj5r\ SSj5rSSjrSSSS\R$S.SSjjrSSjrSSjrSSS.SSjjrSSS.SSjjrSSS.SSjjrSSS.SSjjrSSS.SSjjr\rSSS.SSjjrSSS.SSjjrSSS.SSjjrSSSS\R$S.SSjjr\ SSSSSSS .SS!jjj5r!\ SS"j5r!SSSSSSS .SS#jjjr!SSS$jjr"SS%jr#SS&jr$SSSS'.SS(jjr%SSS)jjr&SS*jr'SSS+jjr(S,S-.SS.jjr)S/r*SSS0jjr+SS1.SS2jjr,SS3jr-SSS4jjr.\ SSSSSS5.SS6jjj5r/\ SSSSS5.SS7jj5r/SSSSSS5.SS8jjjr/SSSSSS9.SS:jjr0SSS;S<.SS=jjjr1SS>jr2SSS;S<.SS?jjjr3SS@jr4SSAjr5SSBjr6SSCjr7SSDjr8\ SSSSSSSE.SSFjj5r9\ SSSSSSSE.SSGjj5r9\ SSSSSSSSSSH.SSIjjj5r9SSSSSSSSSSH.SSJjjjr9SSKjr:SSSLjjr;SSSMjjr<\ SSNj5r=\ SSSOjj5r=SSSPjjr=SSSSSSSQ.SSRjjr>SSSSSSS.SSTjjr?SSSUjjr@SSSVjjrASSSSSSSE.SSWjjrBSSXjrCSSSYjjrDSSSZjjrESSS[jjrFSSS\jjrGSSS]jjrHSSS^jjrISSS_jjrJS`S`Sa.SSbjjrKS`S`Sa.SScjjrLS`S`Sa.SSdjjrMS`S`Sa.SSejjrNS`S`Sa.SSfjjrOS`S`Sa.SSgjjrPS`S`Sa.SShjjrQSSijrRSSSjjjrS\ SSk.SSljj5rT\ SSk.SSmjj5rTSSSn.SSojjrTSSpjrUSSqjrVSSSSSr.SSsjjjrWSSSSr.SStjjrXSSSujjrYSvSSSw.SSxjjrZSSyjr[SSSzjjr\S{r]g)LogfirezThe main logfire class.NTlogfire)config sample_ratetags console_log otel_scopecb[U5UlXlX lX@lXPl0UlgN)tuple_tags_config _sample_rate _console_log _otel_scope _variables)selfrzr{r|r}r~s S/home/mande/repo/quber/.venv/lib/python3.13/site-packages/logfire/_internal/main.py__init__Logfire.__init__s-4[  ''%46cUR$r)rrs rrzLogfire.configs ||rcBURRR$r)_tracer_providerresource attributesrs rresource_attributesLogfire.resource_attributess$$--888rclURRS5 URR5$)Nz No logs or spans will be created)rwarn_if_not_initializedget_tracer_providerrs rrLogfire._tracer_providers( ,,-OP||//11rc6URR5$r)rget_meter_providerrs r_meter_providerLogfire._meter_providers||..00rcVURRUR[5$r)r get_meterrr#rs r_meterLogfire._meters!##--d.>.>HHrc URSS9$)NFis_span_tracer _get_tracerrs r _logs_tracerLogfire._logs_tracersu55rc URSS9$)NTrrrs r _spans_tracerLogfire._spans_tracerst44rcTURRUR[US9$)Nr)r get_tracerrr#)rrs rrLogfire._get_tracers/$$//    )0  rr _span_name_level_links _span_kindc Ub8[U5nU[n XRR:a [ 5$OSn[ 5n 0U EUEn UR R(a [R"5Rn OSn [UU UR RU S9upnU RU5 URU5 X['X['[!U 5n[#U5=n(a[%U5U[&'UR(=(d S[+U=(d S5-nU(a[-U5U[.'UR0b UR0OUR3[4S5nUbUS:wa UU[4'UbURU5 [7U=(d UUUR8UUUS9$![:a [=5 [ 5s$f=f)N fstring_framerxr$)links span_kind)r6r,rz min_levelNoopSpanr@rinspect_argumentsinspect currentframef_backr8scrubberupdater.r-prepare_otlp_attributesr=r<r+rrrHr1rpopr/ LogfireSpanr ExceptionrG)r msg_templaterrrrrrlevel_attributes level_num stack_infomerged_attributesr log_message extra_attrsotlp_attributesjson_schema_propertiesr|r{s r_span Logfire._spans: !#7#? ,-IJ {{444#:%5$( ,.J <: < < ||-- ' 4 4 6 = = $ 5N! %%+ 6 2Kl  $ $[ 1   k *AM= >8C4 556GHO)J:)VV%V>TUk>l :;JJ$"ekr(::D7H7N 34$$0!!$(()CTJ  &;!+;>I :;+&&'78*l""&$     :  s9G F G G*)G*c URR"SXS.UD6n[U5$![a [ 5 [ 5s$f=f)zA simple version of `_span` optimized for auto-tracing that doesn't support message formatting. Returns a similarly simplified version of `LogfireSpan` which must immediately be used as a context manager. )namerrx)r start_spanFastLogfireSpanrrGr)rrrkwargsspans r _fast_spanLogfire._fast_spansN  %%00\d\U[\D"4( (   :  s(+A  A c NU[n[XSURR5U['[ U5=n(a[ U5U['UR[U55 UR"X40UD6$![a [5 [5s$f=f)zA version of `_span` used by `@instrument` with `extract_args=True`. This is a bit faster than `_span` but not as fast as `_fast_span` because it supports message formatting and arbitrary types of attributes. )r.r7rrr-r=r<r+rrrrrGr)rrr function_argsrrrs r_instrument_span_with_args"Logfire._instrument_span_with_argss  *+J KL1? ]a]i]i]r]r1sJ- .)J=)YY%Y9OPf9g 56   5mD E??4>v> >   :  sBBB$#B$F)r _exc_infoc j[SU55(a [S5eURSXX#S9 g)aLog a trace message. ```py import logfire logfire.configure() logfire.trace('This is a trace log') ``` Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. c3B# UHoRS5v M g7f_N startswith.0ks r Logfire.trace..I5*Q||C  */Attribute keys cannot start with an underscore.tracer|exc_infoNany ValueErrorlogrrrrrs rr Logfire.trace-38 5*5 5 5NO O ,Src j[SU55(a [S5eURSXX#S9 g)aLog a debug message. ```py import logfire logfire.configure() logfire.debug('This is a debug log') ``` Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. c3B# UHoRS5v M g7frrrs rr Logfire.debug..irrrdebugrNrrs rr Logfire.debugMrrc j[SU55(a [S5eURSXX#S9 g)aLog an info message. ```py import logfire logfire.configure() logfire.info('This is an info log') ``` Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. c3B# UHoRS5v M g7frrrs rrLogfire.info..rrrinforNrrs rr Logfire.infoms38 5*5 5 5NO O Rrc j[SU55(a [S5eURSXX#S9 g)aLog a notice message. ```py import logfire logfire.configure() logfire.notice('This is a notice log') ``` Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. c3B# UHoRS5v M g7frrrs rr!Logfire.notice..rrrnoticerNrrs rrLogfire.notices38 5*5 5 5NO O <%Trc j[SU55(a [S5eURSXX#S9 g)aLog a warning message. ```py import logfire logfire.configure() logfire.warning('This is a warning log') ``` `logfire.warn` is an alias of `logfire.warning`. Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. c3B# UHoRS5v M g7frrrs rr"Logfire.warning..rrrwarnrNrrs rwarningLogfire.warnings3< 5*5 5 5NO O Rrc j[SU55(a [S5eURSXX#S9 g)aLog an error message. ```py import logfire logfire.configure() logfire.error('This is an error log') ``` Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. c3B# UHoRS5v M g7frrrs rr Logfire.error..rrrerrorrNrrs rr  Logfire.errorrrc j[SU55(a [S5eURSXX#S9 g)aLog a fatal message. ```py import logfire logfire.configure() logfire.fatal('This is a fatal log') ``` Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. c3B# UHoRS5v M g7frrrs rr Logfire.fatal.. rrrfatalrNrrs rr Logfire.fatalrrc j[SU55(a [S5eURSXX#S9 g)aThe same as `error` but with `_exc_info=True` by default. This means that a traceback will be logged for any currently handled exception. Args: msg_template: The message to log. attributes: The attributes to bind to the log. _tags: An optional sequence of tags to include in the log. _exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. c3B# UHoRS5v M g7frrrs rr$Logfire.exception..%rrrr rNrrs r exceptionLogfire.exceptions3( 5*5 5 5NO O ,Src p[SU55(a [S5eURUUUUUUUS9$)aContext manager for creating a span. ```py import logfire logfire.configure() with logfire.span('This is a span {a=}', a='data'): logfire.info('new log 1') ``` Args: msg_template: The template for the span message. _span_name: The span name. If not provided, the `msg_template` will be used. _tags: An optional sequence of tags to include in the span. _level: An optional log level name. _links: An optional sequence of links to other spans. Each link is a tuple of a span context and attributes. _span_kind: The [OpenTelemetry span kind](https://opentelemetry.io/docs/concepts/signals/traces/#span-kind). If not provided, defaults to `INTERNAL`. Users don't typically need to set this. Not related to the `kind` column of the `records` table in Logfire. attributes: The arguments to include in the span and format the message template with. Attributes starting with an underscore are not allowed. c3B# UHoRS5v M g7frrrs rrLogfire.span..Mrrrr)rrr)rrrrrrrrs rr Logfire.span)sMH 5*5 5 5NO Ozz  !!  r) span_name extract_args record_returnallow_generator new_tracecg) Decorator for instrumenting a function as a span. ```py import logfire logfire.configure() @logfire.instrument('This is a span {a=}') def my_function(a: int): logfire.info('new log {a=}', a=a) ``` Args: msg_template: The template for the span message. If not provided, the module and function name will be used. span_name: The span name. If not provided, the `msg_template` will be used. extract_args: By default, all function call arguments are logged as span attributes. Set to `False` to disable this, or pass an iterable of argument names to include. record_return: Set to `True` to record the return value of the function as an attribute. Ignored for generators. allow_generator: Set to `True` to prevent a warning when instrumenting a generator function. Read https://logfire.pydantic.dev/docs/guides/advanced/generators/#using-logfireinstrument first. new_trace: Set to `True` to start a new trace with a span link to the current span instead of creating a child of the current span. Nrxrrrrrr r!s rr9Logfire.instrumentYrcg)zDecorator for instrumenting a function as a span, with default configuration. ```py import logfire logfire.configure() @logfire.instrument def my_function(a: int): logfire.info('new log {a=}', a=a) ``` Nrx)rfuncs rr9r%~r&rc [U5(aUR5"U5$[U[UR5XX4XV5$)r#)callabler9rrr$s rr9r%sDF L ! !??$\2 2 % #\l[j  rc[ [U5nU[nXRR:a SSS5 g[ 5n U=(d 0n0U EUEn UR [S5=n cSn URR(ag[R"5n U RRR[R R"R:Xa U Rn [%UU URR&U S9upnU (aU R)U 5 0UEU EnO[+U 5=o['[+U5n[-U 5n[.S0UE[0U[U 0EUEn[3U5=n(a[5U5U[6'UR8[;U=(d S5-nU(a[=U5U[>'UR@b UR@OUR [BS5nUbUS:wa UU[B'UcURD(dOU(d SU[F'URRHRK5nURLROUUUS9nURQ5(d SSS5 gU(aUSLa[RRT"5n[WU[:5(aUSn[WU[X5(a2UR[U5 U[[\S:a [_UU5 O%Ub"[aS URbRd35eURgU5 SSS5 g!,(df  g=f) aKLog a message. ```py import logfire logfire.configure() logfire.log('info', 'This is a log {a}', {'a': 'Apple'}) ``` Args: level: The level of the log. msg_template: The message to log. attributes: The attributes to bind to the log. tags: An optional sequence of tags to include in the log. exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info] to record a traceback with the log message. Set to `True` to use the currently handled exception. console_log: Whether to log to the console, defaults to `True`. Nrrrxr$T)r start_timer zInvalid type for exc_info: )4rFr6r,rzrr@rr-rrrrrf_code co_filenamervr__code__r8rrstrrr0r.r=r<r+rrrHr1rr/rr2advancedns_timestamp_generatorrr is_recordingsysr isinstance BaseExceptionrecord_exceptionr3rD TypeError __class____name__end)rlevelrrr|rr}rrrrmsgrrrrr{r,rs rr Logfire.logs'<$3E: ()EFI;;000 $ # -.J#)rJ <: < < !~~&>'++BVBVBbBbb)6(<(< 1J %LL))"/ 2., %,,[9"?J!>+!>JCFc(J(>?"<0 56GHO(%"0&  " O*K:)VV%V>TUk>l :;::djb 11D7H7N 34$$0!!$(()CTJ  &;!+;>I :;)4)+Ft''   OWWjVkLl   rc8URRU5$)zForce flush all spans and metrics. Args: timeout_millis: The timeout in milliseconds. Returns: Whether the flush of spans was successful. )r force_flush)rtimeout_milliss rrJLogfire.force_flushus||''77rcURRnURnURnU(aU(aU(dgUR S5SUSU3$)zGenerate a Logfire URL to view an evaluation report. Args: report: An evaluation report from `pydantic_evals`. Returns: The URL string, or `None` if the project URL or trace/span IDs are not available. N/z/evals/compare?experiment=-)r _project_urltrace_idspan_idrstrip)rreport project_urlrQrRs r url_from_evalLogfire.url_from_evalsTll// ??..('$$S)**DXJaPWyYYrc.[R"X5$)aOLog a warning whenever a function running in the asyncio event loop blocks for too long. This works by patching the `asyncio.events.Handle._run` method. Args: slow_duration: the threshold in seconds for when a callback is considered slow. Returns: A context manager that will revert the patch when exited. This context manager doesn't take into account threads or other concurrency. Calling this method will immediately apply the patch without waiting for the context manager to be opened, i.e. it's not necessary to use this as a context manager. )r%log_slow_callbacks)r slow_durations rlog_slow_async_callbacks Logfire.log_slow_async_callbackss((==rr )check_imported_modulesc[XX2S9 g)aInstall automatic tracing. See the [Auto-Tracing guide](https://logfire.pydantic.dev/docs/guides/onboarding_checklist/add_auto_tracing/) for more info. This will trace all non-generator function calls in the modules specified by the modules argument. It's equivalent to wrapping the body of every function in matching modules in `with logfire.span(...):`. !!! note This function MUST be called before any of the modules to be traced are imported. Generator functions will not be traced for reasons explained [here](https://logfire.pydantic.dev/docs/guides/advanced/generators/). This works by inserting a new meta path finder into `sys.meta_path`, so inserting another finder before it may prevent it from working. It relies on being able to retrieve the source code via at least one other existing finder in the meta path, so it may not work if standard finders are not present or if the source code is not available. A modified version of the source code is then compiled and executed in place of the original module. Args: modules: List of module names to trace, or a function which returns True for modules that should be traced. If a list is provided, any submodules within a given module will also be traced. min_duration: A minimum duration in seconds for which a function must run before it's traced. Setting to `0` causes all functions to be traced from the beginning. Otherwise, the first time(s) each function is called, it will be timed but not traced. Only after the function has run for at least `min_duration` will it be traced in subsequent calls. check_imported_modules: If this is `'error'` (the default), then an exception will be raised if any of the modules in `sys.modules` (i.e. modules that have already been imported) match the modules to trace. Set to `'warn'` to issue a warning instead, or `'ignore'` to skip the check. )r] min_durationN)r')rmodulesr_r]s rr'Logfire.install_auto_tracingsL TCYurc:URRS5 g)Nz#Instrumentation will have no effect)rzrrs r,_warn_if_not_initialized_for_instrumentation4Logfire._warn_if_not_initialized_for_instrumentations ++,QRrc@SSKJn UR5 U"X5 g)a;Instrument [SurrealDB](https://surrealdb.com/) connections, creating a span for each method. Args: obj: Pass a single connection instance to instrument only that connection. Pass a connection class to instrument all instances of that class. By default, all connection classes are instrumented. r$)instrument_surrealdbN)integrations.surrealdbrfrc)robjrfs rrfLogfire.instrument_surrealdbs A 99;S'r)propagate_otel_contextc@SSKJn UR5 U"X5 g)aInstrument the [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk). Instruments both the client and server side. If possible, calling this in both the client and server processes is recommended for nice distributed traces. Args: propagate_otel_context: Whether to enable propagation of the OpenTelemetry context for distributed tracing. Set to False to prevent setting extra fields like `traceparent` on the metadata of requests. r$)instrument_mcpN)integrations.mcprlrc)rrjrls rrlLogfire.instrument_mcps 5 99;t4rc>SSKJn UR5 U"U5$)amInstrument the [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview). All `ClaudeSDKClient` instances created after this call will be automatically traced. Existing instances created before this call will not have tool call tracing. Returns: A context manager that will revert the instrumentation when exited. This context manager doesn't take into account threads or other concurrency. Calling this method will immediately apply the instrumentation without waiting for the context manager to be opened, i.e. it's not necessary to use this as a context manager. r$)instrument_claude_agent_sdk)integrations.claude_agent_sdkrprc)rrps rrp#Logfire.instrument_claude_agent_sdks O 99;*400rc "US:wa1SSKn[UR5[S5:a [S5eSSKJnJn [U[5(aU1n[U[5(aU1nU"U"U[U5[U5S95 g)aInstrument Pydantic model validations. This must be called before defining and importing the model classes you want to instrument. See the [Pydantic integration guide](https://logfire.pydantic.dev/docs/integrations/pydantic/) for more info. Args: record: The record mode for the Pydantic plugin. It can be one of the following values: - `all`: Send traces and metrics for all events. This is default value. - `failure`: Send metrics for all validations and traces only for validation failures. - `metrics`: Send only metrics. - `off`: Disable instrumentation. include: By default, third party modules are not instrumented. This option allows you to include specific modules. exclude: Exclude specific modules from instrumentation. offrNz2.5.0z5The Pydantic plugin requires Pydantic 2.5.0 or newer.)PydanticPluginset_pydantic_plugin_config)recordincludeexclude) pydanticrE __version__ RuntimeErrorlogfire.integrations.pydanticrurvr5r0set)rrwrxryrzrurvs rinstrument_pydanticLogfire.instrument_pydantics4 U? 8//0;w3GG"#Z[[\ gs # #iG gs # #iG # G G   r)include_binary_contentinclude_contentversion event_modec grrxrrhrrrrrs rinstrument_pydantic_aiLogfire.instrument_pydantic_ai.src grrxrs rrr;s$'rc LSSKJn UR5 U"U4UUUUUS.UD6$)a7Instrument Pydantic AI. Args: obj: What to instrument. By default, all agents are instrumented. You can also pass a specific model or agent. If you pass a model, a new instrumented model will be returned. include_binary_content: Whether to include base64 encoded binary content (e.g. images) in the telemetry. On by default. Requires Pydantic AI 0.2.5 or newer. include_content: Whether to include prompts, completions, and tool call arguments and responses in the telemetry. On by default. Requires Pydantic AI 0.3.4 or newer. version: Version of the data format. This is unrelated to the Pydantic AI package version. Requires Pydantic AI 0.7.5 or newer. Version 1 is based on the legacy event-based OpenTelemetry GenAI spec and will be removed in a future release. The parameter `event_mode` is only relevant for version 1. Version 2 uses the newer OpenTelemetry GenAI spec and stores messages in the following attributes: - `gen_ai.system_instructions` for instructions passed to the agent. - `gen_ai.input.messages` and `gen_ai.output.messages` on model request spans. - `pydantic_ai.all_messages` on agent run spans. Version 3 changes the names of some attributes and spans but not the shape of the data. The default version depends on Pydantic AI. event_mode: The mode for emitting events in version 1. If `'attributes'`, events are attached to the span as attributes. If `'logs'`, events are emitted as OpenTelemetry log-based events. kwargs: Additional keyword arguments to pass to [`InstrumentationSettings`](https://ai.pydantic.dev/api/models/instrumented/#pydantic_ai.models.instrumented.InstrumentationSettings) for future compatibility. r$)r)rhrrrr)integrations.pydantic_airrc)rrhrrrrrrs rrrHsCP E 99;%  !+#9    rcapture_headersrequest_attributes_mapper excluded_urlsrecord_send_receive extra_spansc NSSKJn UR5 U"UU4UUUUUS.UD6$)a* Instrument a FastAPI app so that spans and logs are automatically created for each request. Uses the [OpenTelemetry FastAPI Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/fastapi/fastapi.html) under the hood, with some additional features. Args: app: The FastAPI app to instrument. capture_headers: Set to `True` to capture all request and response headers. request_attributes_mapper: A function that takes a [`Request`][fastapi.Request] or [`WebSocket`][fastapi.WebSocket] and a dictionary of attributes and returns a new dictionary of attributes. The input dictionary will contain: - `values`: A dictionary mapping argument names of the endpoint function to parsed and validated values. - `errors`: A list of validation errors for any invalid inputs. The returned dictionary will be used as the attributes for a log message. If `None` is returned, no log message will be created. You can use this to e.g. only log validation errors, or nothing at all. You can also add custom attributes. The default implementation will return the input dictionary unchanged. The function mustn't modify the contents of `values` or `errors`. excluded_urls: A string of comma-separated regexes which will exclude a request from tracing if the full URL matches any of the regexes. This applies to both the Logfire and OpenTelemetry instrumentation. If not provided, the environment variables `OTEL_PYTHON_FASTAPI_EXCLUDED_URLS` and `OTEL_PYTHON_EXCLUDED_URLS` will be checked. record_send_receive: Set to `True` to allow the OpenTelemetry ASGI middleware to create send/receive spans. These are disabled by default to reduce overhead and the number of spans created, since many can be created for a single request, and they are not often useful. If enabled, they will be set to debug level, meaning they will usually still be hidden in the UI. extra_spans: Whether to include the extra 'FastAPI arguments' and 'endpoint function' spans. opentelemetry_kwargs: Additional keyword arguments to pass to the OpenTelemetry FastAPI instrumentation. Returns: A context manager that will revert the instrumentation when exited. This context manager doesn't take into account threads or other concurrency. Calling this method will immediately apply the instrumentation without waiting for the context manager to be opened, i.e. it's not necessary to use this as a context manager. r$)instrument_fastapir)integrations.fastapirrc) rapprrrrropentelemetry_kwargsrs rrLogfire.instrument_fastapi~sGx = 99;!    ,&?' 3#  #  rr$)suppress_other_instrumentationrc SSKnSSKJn SSKJnJnJn SSKJn U "U5n UR5 U"UU=(d URUR4US[XjS9[XS9U5$) u) 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 of the OpenAI "agents" framework, see [`instrument_openai_agents()`][logfire.Logfire.instrument_openai_agents]. The following methods are instrumented for both the sync and the async clients: - [`client.chat.completions.create`](https://platform.openai.com/docs/guides/text-generation/chat-completions-api) — with and without `stream=True` - [`client.completions.create`](https://platform.openai.com/docs/guides/text-generation/completions-api) — with and without `stream=True` - [`client.embeddings.create`](https://platform.openai.com/docs/guides/embeddings/how-to-get-embeddings) - [`client.images.generate`](https://platform.openai.com/docs/guides/images/generations) When `stream=True` a second span is created to instrument the streamed response. Example usage: ```python skip-run="true" skip-reason="external-connection" import openai import logfire client = openai.OpenAI() logfire.configure() logfire.instrument_openai(client) response = client.chat.completions.create( model='gpt-4', messages=[ {'role': 'system', 'content': 'You are a helpful assistant.'}, {'role': 'user', 'content': 'What is four plus five?'}, ], ) print('answer:', response.choices[0].message.content) ``` Args: openai_client: The OpenAI client or class to instrument: - `None` (the default) to instrument both the `openai.OpenAI` and `openai.AsyncOpenAI` classes. - The `openai.OpenAI` class or a subclass - The `openai.AsyncOpenAI` class or a subclass - An instance of `openai.OpenAI` - An instance of `openai.AsyncOpenAI` suppress_other_instrumentation: If True, suppress any other OTEL instrumentation that may be otherwise enabled. In reality, this means the HTTPX instrumentation, which could otherwise be called since OpenAI uses HTTPX to make HTTP requests. 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 (`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. Returns: A context manager that will revert the instrumentation when exited. Use of this context manager is optional. rNr$instrument_llm_providerget_endpoint_configis_async_client on_responsenormalize_versionsOpenAIr) openai'integrations.llm_providers.llm_providerr!integrations.llm_providers.openairrr"integrations.llm_providers.semconvrrcr AsyncOpenAIr ) r openai_clientrrrrrrrrnormalized_versionss rinstrument_openaiLogfire.instrument_openaislT ThhJ09 99;&   @fmmV-?-?@ *  ' E K =   rcRUR5 SSKJn URU5 g)zInstrument the [`agents`](https://github.com/openai/openai-agents-python) framework from OpenAI. For instrumentation of the standard OpenAI SDK package, see [`instrument_openai()`][logfire.Logfire.instrument_openai]. r$)LogfireTraceProviderWrapperN)rcintegrations.openai_agentsrinstall)rrs rinstrument_openai_agents Logfire.instrument_openai_agents$s! 99;K#++D1rc SSKnSSKJnJnJn SSKJn SSKJn U "U5n UR5 U"UU=(d. URURURUR4US[XZS9[XzS9U5$) aW 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: - [`client.messages.create`](https://docs.anthropic.com/en/api/messages) - [`client.messages.stream`](https://docs.anthropic.com/en/api/messages-streaming) - [`client.beta.tools.messages.create`](https://docs.anthropic.com/en/docs/tool-use) When `stream=True` a second span is created to instrument the streamed response. Example usage: ```python skip-run="true" skip-reason="external-connection" import anthropic import logfire client = anthropic.Anthropic() logfire.configure() logfire.instrument_anthropic(client) response = client.messages.create( model='claude-3-haiku-20240307', system='You are a helpful assistant.', messages=[ {'role': 'user', 'content': 'What is four plus five?'}, ], ) print('answer:', response.content[0].text) ``` Args: anthropic_client: The Anthropic client or class to instrument: - `None` (the default) to instrument all Anthropic client types - The `anthropic.Anthropic` or `anthropic.AnthropicBedrock` class or subclass - The `anthropic.AsyncAnthropic` or `anthropic.AsyncAnthropicBedrock` class or subclass - An instance of any of the above classes suppress_other_instrumentation: If True, suppress any other OTEL instrumentation that may be otherwise enabled. In reality, this means the HTTPX instrumentation, which could otherwise be called since OpenAI uses HTTPX to make HTTP requests. 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 (`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. Returns: A context manager that will revert the instrumentation when exited. Use of this context manager is optional. rNr$rrr Anthropicr) anthropic$integrations.llm_providers.anthropicrrrrrrrrcrAsyncAnthropicAnthropicBedrockAsyncAnthropicBedrockr ) ranthropic_clientrrrrrrrrrs rinstrument_anthropicLogfire.instrument_anthropic0sV kkTJ09 99;&   ##((**//  +  ' E K =   rc BSSKJn UR5 U"U40UD6 g)aInstrument the [Google Gen AI SDK (`google-genai`)](https://googleapis.github.io/python-genai/). !!! note To capture message contents (i.e. prompts and completions), set the environment variable `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` to `true`. Uses the `GoogleGenAiSdkInstrumentor().instrument()` method of the [`opentelemetry-instrumentation-google-genai`](https://pypi.org/project/opentelemetry-instrumentation-google-genai/) package, to which it passes `**kwargs`. r$)instrument_google_genaiN)integrations.google_genairrc)rrrs rrLogfire.instrument_google_genais! G 99;//rc BSSKJn UR5 U"U40UD6 g)aInstrument the [LiteLLM](https://docs.litellm.ai/) Python SDK. !!! warning This currently works best if all arguments of instrumented methods are passed as keyword arguments, e.g. `litellm.completion(model=model, messages=messages)`. Uses the `LiteLLMInstrumentor().instrument()` method of the [`openinference-instrumentation-litellm`](https://pypi.org/project/openinference-instrumentation-litellm/) package, to which it passes `**kwargs`. r$)instrument_litellmN)integrations.litellmrrc)rrrs rrLogfire.instrument_litellms  = 99;4*6*rc BSSKJn UR5 U"U40UD6 g)zInstrument [DSPy](https://dspy.ai/). Uses the `DSPyInstrumentor().instrument()` method of the [`openinference-instrumentation-dspy`](https://pypi.org/project/openinference-instrumentation-dspy/) package, to which it passes `**kwargs`. r$)instrument_dspyN)integrations.dspyrrc)rrrs rrLogfire.instrument_dspys  7 99;''rc>SSKJn UR5 U"U5$)aInstrument 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. r$)instrument_print)integrations.printrrc)rrs rrLogfire.instrument_prints$ 9 99;%%rc SSKJn UR5 U"S0URR 5URR 5S.UED6$)zWInstrument the `asyncpg` module so that spans are automatically created for each query.r$)instrument_asyncpgtracer_providermeter_providerrx)integrations.asyncpgrrcrrr)rrrs rrLogfire.instrument_asyncpgsR< 99;! #'<<#C#C#E"&,,"A"A"C  r) capture_allrcapture_request_bodycapture_response_body request_hook response_hookc grrx rclientrrrrrrrs rinstrument_httpxLogfire.instrument_httpxrc grrxrs rrrrrrrrrrrasync_request_hookasync_response_hookc grrx) rrrrrrrrrrrs rrrsrc TSSKJn UR5 U "UU4UUUUUUUU S.U D6$)aWInstrument the `httpx` module so that spans are automatically created for each request. Optionally, pass an `httpx.Client` instance to instrument only that client. Uses the [OpenTelemetry HTTPX Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/httpx/httpx.html) library, specifically `HTTPXClientInstrumentor().instrument()`, to which it passes `**kwargs`. Args: client: The `httpx.Client` or `httpx.AsyncClient` instance to instrument. If `None`, the default, all clients will be instrumented. capture_all: Set to `True` to capture all HTTP headers, request and response bodies. By default checks the environment variable `LOGFIRE_HTTPX_CAPTURE_ALL`. capture_headers: Set to `True` to capture all HTTP headers. If you don't want to capture all headers, you can customize the headers captured. See the [Capture Headers](https://logfire.pydantic.dev/docs/guides/advanced/capture_headers/) section for more info. capture_request_body: Set to `True` to capture the request body. capture_response_body: Set to `True` to capture the response body. request_hook: A function called right after a span is created for a request. response_hook: A function called right before a span is finished for the response. async_request_hook: A function called right after a span is created for an async request. async_response_hook: A function called right before a span is finished for an async response. **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` method, for future compatibility. r$)rr)integrations.httpxrrc) rrrrrrrrrrrrs rrrsPN 9 99;    $+!5"7%'1 3    rc SSKJn UR5 U"S0URR 5URR 5S.UED6$)aInstrument `celery` so that spans are automatically created for each task. Uses the [OpenTelemetry Celery Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/celery/celery.html) library. For distributed tracing to work correctly, this must be called in **both** the worker processes and the application that enqueues tasks (e.g., your Django or FastAPI web server). See the [distributed tracing guide](https://logfire.pydantic.dev/docs/how-to-guides/distributed-tracing/#integrations). See the [Celery guide](https://logfire.pydantic.dev/docs/integrations/celery/) for more details. Args: **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` method, for future compatibility. r$)instrument_celeryrrx)integrations.celeryrrcrrr)rrrs rrLogfire.instrument_celeryGsT ; 99;  #'<<#C#C#E"&,,"A"A"C  rc SSKJn UR5 U"SUUUUUS.URR 5URR 5S.UED6$)a~Instrument `django` so that spans are automatically created for each web request. Uses the [OpenTelemetry Django Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/django/django.html) library. Args: capture_headers: Set to `True` to capture all request and response headers. is_sql_commentor_enabled: Adds comments to SQL queries performed by Django, so that database logs have additional context. This does NOT create spans/logs for the queries themselves. For that you need to instrument the database driver, e.g. with `logfire.instrument_psycopg()`. To configure the SQL Commentor, see the OpenTelemetry documentation for the values that need to be added to `settings.py`. request_hook: A function called right after a span is created for a request. The function should accept two arguments: the span and the Django `Request` object. response_hook: A function called right before a span is finished for the response. The function should accept three arguments: the span, the Django `Request` object, and the Django `Response` object. excluded_urls: A string containing a comma-delimited list of regexes used to exclude URLs from tracking. **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` method, for future compatibility. r$)instrument_django)ris_sql_commentor_enabledrrrrrx)integrations.djangorrcrrr)rrrrrrrrs rrLogfire.instrument_djangobskN ; 99;  +%=%''  $(<<#C#C#E"&,,"A"A"C  rc SSKJn UR5 U"SUUUS.URR 5URR 5S.UED6$)aInstrument the `requests` module so that spans are automatically created for each request. Args: excluded_urls: A string containing a comma-delimited list of regexes used to exclude URLs from tracking request_hook: A function called right after a span is created for a request. response_hook: A function called right before a span is finished for the response. **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` methods, for future compatibility. r$)instrument_requests)rrrrrx)integrations.requestsrrcrrr)rrrrrrs rrLogfire.instrument_requestssd ? 99;"  '%'  $(<<#C#C#E"&,,"A"A"C  rc grrx)rconn_or_modulers rinstrument_psycopgLogfire.instrument_psycopgsqtrc grrx)rrenable_commentercommenter_optionsrs rrrsrc SSKJn UR5 U(aURSU=(d 0S.5 U"U4SU0UD6$)aInstrument a `psycopg` connection or module so that spans are automatically created for each query. Uses the OpenTelemetry instrumentation libraries for [`psycopg`](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/psycopg/psycopg.html) and [`psycopg2`](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/psycopg2/psycopg2.html). Args: conn_or_module: Can be: - The `psycopg` (version 3) or `psycopg2` module. - The string `'psycopg'` or `'psycopg2'` to instrument the module. - `None` (the default) to instrument whichever module(s) are installed. - A `psycopg` or `psycopg2` connection. enable_commenter: Adds comments to SQL queries performed by Psycopg, so that database logs have additional context. commenter_options: Configure the tags to be added to the SQL comments. **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` methods, for future compatibility. r$)rT)rrr)integrations.psycopgrrcr)rrrrrrs rrrsC6 = 99;  MMtJ[Ja_ab c!$P~PPPrrrrrrrc SSKJn UR5 U "U4UUUUUUS.URR 5URR 5S.UED6$)aInstrument `app` so that spans are automatically created for each request. Uses the [OpenTelemetry Flask Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/flask/flask.html) library, specifically `FlaskInstrumentor().instrument_app()`, to which it passes `**kwargs`. Args: app: The Flask app to instrument. capture_headers: Set to `True` to capture all request and response headers. enable_commenter: Adds comments to SQL queries performed by Flask, so that database logs have additional context. commenter_options: Configure the tags to be added to the SQL comments. See more about it on the [SQLCommenter Configurations](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/flask/flask.html#sqlcommenter-configurations). excluded_urls: A string containing a comma-delimited list of regexes used to exclude URLs from tracking. request_hook: A function called right after a span is created for a request. 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. r$)instrument_flaskrr)integrations.flaskrrcrrr) rrrrrrrrrrs rrLogfire.instrument_flasksp: 9 99;   +-/'%'  $(<<#C#C#E"&,,"A"A"C  r)rrserver_request_hookclient_request_hookclient_response_hookc NSSKJn UR5 U"UU4UUUUUS.UD6$)a(Instrument `app` so that spans are automatically created for each request. Uses the [OpenTelemetry Starlette Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/starlette/starlette.html) library, specifically `StarletteInstrumentor.instrument_app()`, to which it passes `**kwargs`. Args: app: The Starlette app to instrument. capture_headers: Set to `True` to capture all request and response headers. record_send_receive: Set to `True` to allow the OpenTelemetry ASGI middleware to create send/receive spans. These are disabled by default to reduce overhead and the number of spans created, since many can be created for a single request, and they are not often useful. If enabled, they will be set to debug level, meaning they will usually still be hidden in the UI. server_request_hook: A function that receives a server span and the ASGI scope for every incoming request. client_request_hook: A function that receives a span, the ASGI scope and the receive ASGI message for every ASGI receive event. client_response_hook: A function that receives a span, the ASGI scope and the send ASGI message for every ASGI send event. **kwargs: Additional keyword arguments to pass to the OpenTelemetry Starlette instrumentation. r$)instrument_starlette)rrrrr)integrations.starletterrc) rrrrrrrrrs rrLogfire.instrument_starlettesG< A 99;#    !4+ 3 3!5    rc HSSKJn UR5 U"UU4UUS.UD6$)aInstrument `app` so that spans are automatically created for each request. Uses the ASGI [`OpenTelemetryMiddleware`][opentelemetry.instrumentation.asgi.OpenTelemetryMiddleware] under the hood, to which it passes `**kwargs`. Warning: Instead of modifying the app in place, this method returns the instrumented ASGI application. Args: app: The ASGI application to instrument. capture_headers: Set to `True` to capture all request and response headers. record_send_receive: Set to `True` to allow the OpenTelemetry ASGI middleware to create send/receive spans. These are disabled by default to reduce overhead and the number of spans created, since many can be created for a single request, and they are not often useful. If enabled, they will be set to debug level, meaning they will usually still be hidden in the UI. **kwargs: Additional keyword arguments to pass to the OpenTelemetry ASGI middleware. Returns: The instrumented ASGI application. r$)instrument_asgi)rr)integrations.asgir rc)rrrrrr s rr Logfire.instrument_asgi?s=8 7 99;   !4+     rc SSKJn UR5 U"U4UUUS.URR 5URR 5S.UED6$)aInstrument `app` so that spans are automatically created for each request. Uses the WSGI [`OpenTelemetryMiddleware`][opentelemetry.instrumentation.wsgi.OpenTelemetryMiddleware] under the hood, to which it passes `**kwargs`. Warning: Instead of modifying the app in place, this method returns the instrumented WSGI application. Args: app: The WSGI application to instrument. capture_headers: Set to `True` to capture all request and response headers. request_hook: A function called right after a span is created for a request. response_hook: A function called right before a span is finished for the response. **kwargs: Additional keyword arguments to pass to the OpenTelemetry WSGI middleware. Returns: The instrumented WSGI application. r$)instrument_wsgi)rrrr)integrations.wsgir rcrrr)rrrrrrr s rr Logfire.instrument_wsgifsg4 7 99;   +%'  $(<<#C#C#E"&,,"A"A"C  rc NSSKJn UR5 U"U4UUUUUUS.UD6$)amInstrument the `aiohttp` module so that spans are automatically created for each client request. Uses the [OpenTelemetry aiohttp client Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/aiohttp_client/aiohttp_client.html) library, specifically `AioHttpClientInstrumentor().instrument()`, to which it passes `**kwargs`. r$)instrument_aiohttp_client)rrrrrr)integrations.aiohttp_clientrrc) rrrrrrrrrs rr!Logfire.instrument_aiohttp_clientsE" K 99;(   #!5"7+%'    rc SSKJn UR5 U"S0URR 5URR 5S.UED6$)amInstrument the `aiohttp` module so that spans are automatically created for each server request. Uses the [OpenTelemetry aiohttp server Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/aiohttp_server/aiohttp_server.html) library, specifically `AioHttpServerInstrumentor().instrument()`, to which it passes `**kwargs`. r$)instrument_aiohttp_serverrrx)integrations.aiohttp_serverrrcrrr)rrrs rr!Logfire.instrument_aiohttp_serversU K 99;( #'<<#C#C#E"&,,"A"A"C  rc SSKJn UR5 U"SUUUU=(d 0S.URR 5URR 5S.UED6$)aInstrument the `sqlalchemy` module so that spans are automatically created for each query. Uses the [OpenTelemetry SQLAlchemy Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/sqlalchemy/sqlalchemy.html) library, specifically `SQLAlchemyInstrumentor().instrument()`, to which it passes `**kwargs`. Args: engine: The `sqlalchemy` engine to instrument. engines: An iterable of `sqlalchemy` engines to instrument. enable_commenter: Adds comments to SQL queries performed by SQLAlchemy, so that database logs have additional context. commenter_options: Configure the tags to be added to the SQL comments. **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` methods. r$)instrument_sqlalchemy)engineenginesrrrrx)integrations.sqlalchemyrrcrrr)rrrrrrrs rrLogfire.instrument_sqlalchemysm* C 99;$  -/52  $(<<#C#C#E"&,,"A"A"C  rc zSSKJn UR5 U"SSU0SURR 50UED6$)aRInstrument the `sqlite3` module or a specific connection so that spans are automatically created for each operation. Uses the [OpenTelemetry SQLite3 Instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/sqlite3/sqlite3.html) library. Args: conn: The `sqlite3` connection to instrument, or `None` to instrument all connections. **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` methods. Returns: If a connection is provided, returns the instrumented connection. If no connection is provided, returns `None`. r$)instrument_sqlite3connrrx)integrations.sqlite3rrcrr)rr rrs rrLogfire.instrument_sqlite3s? = 99;!qtq0A4<s rmetric_counterLogfire.metric_counters8{{))$kBBrc:URRXU5$)akCreate a histogram metric. A histogram is a metric that samples observations (usually things like request durations or response sizes). ```py import logfire logfire.configure() histogram = logfire.metric_histogram('bank.amount_transferred', unit='$', description='Amount transferred') def transfer(amount: int): histogram.record(amount) ``` See the [Opentelemetry documentation](https://opentelemetry.io/docs/specs/otel/metrics/api/#histogram) about Args: name: The name of the metric. unit: The unit of the metric. description: The description of the metric. Returns: The histogram metric. )rcreate_histogramrAs rmetric_histogramLogfire.metric_histograms4{{++D DDrc:URRXU5$)aACreate a gauge metric. Gauge is a synchronous instrument which can be used to record non-additive measurements. ```py import logfire logfire.configure() gauge = logfire.metric_gauge('system.cpu_usage', unit='%', description='CPU usage') def update_cpu_usage(cpu_percent): gauge.set(cpu_percent) ``` See the [Opentelemetry documentation](https://opentelemetry.io/docs/specs/otel/metrics/api/#gauge) about gauges. Args: name: The name of the metric. unit: The unit of the metric. description: The description of the metric. Returns: The gauge metric. )r create_gaugerAs r metric_gaugeLogfire.metric_gauges4{{''K@@rc:URRXU5$)aCreate an up-down counter metric. An up-down counter is a cumulative metric that represents a single numerical value that can be adjusted up or down. ```py import logfire logfire.configure() up_down_counter = logfire.metric_up_down_counter('users.logged_in', unit='1', description='Users logged in') def on_login(user): up_down_counter.add(1) def on_logout(user): up_down_counter.add(-1) ``` See the [Opentelemetry documentation](https://opentelemetry.io/docs/specs/otel/metrics/api/#updowncounter) about up-down counters. Args: name: The name of the metric. unit: The unit of the metric. description: The description of the metric. Returns: The up-down counter metric. )rcreate_up_down_counterrAs rmetric_up_down_counterLogfire.metric_up_down_counters@{{11$kJJrc<URRXX45 g)aCreate a counter metric that uses a callback to collect observations. The callback is called every 60 seconds in a background thread. The counter metric is a cumulative metric that represents a single numerical value that only ever goes up. ```py import psutil from opentelemetry.metrics import CallbackOptions, Observation import logfire logfire.configure() def cpu_usage_callback(options: CallbackOptions): cpu_percents = psutil.cpu_percent(percpu=True) for i, cpu_percent in enumerate(cpu_percents): yield Observation(cpu_percent, {'cpu': i}) cpu_usage_counter = logfire.metric_counter_callback( 'system.cpu.usage', callbacks=[cpu_usage_callback], unit='%', description='CPU usage', ) ``` See the [Opentelemetry documentation](https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-counter) about asynchronous counter. Args: name: The name of the metric. callbacks: A sequence of callbacks that return an iterable of [Observation](https://opentelemetry-python.readthedocs.io/en/latest/api/metrics.html#opentelemetry.metrics.Observation). unit: The unit of the metric. description: The description of the metric. N)rcreate_observable_counterrr callbacksr=r>s rmetric_counter_callbackLogfire.metric_counter_callbacks` --dtQrc<URRXX45 g)a:Create a gauge metric that uses a callback to collect observations. The callback is called every 60 seconds in a background thread. The gauge metric is a metric that represents a single numerical value that can arbitrarily go up and down. ```py import threading from opentelemetry.metrics import CallbackOptions, Observation import logfire logfire.configure() def thread_count_callback(options: CallbackOptions): yield Observation(threading.active_count()) logfire.metric_gauge_callback( 'system.thread_count', callbacks=[thread_count_callback], unit='1', description='Number of threads', ) ``` See the [Opentelemetry documentation](https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-gauge) about asynchronous gauge. Args: name: The name of the metric. callbacks: A sequence of callbacks that return an iterable of [Observation](https://opentelemetry-python.readthedocs.io/en/latest/api/metrics.html#opentelemetry.metrics.Observation). unit: The unit of the metric. description: The description of the metric. N)rcreate_observable_gaugerRs rmetric_gauge_callbackLogfire.metric_gauge_callback0 sR ++DTOrc<URRXX45 g)aTCreate an up-down counter metric that uses a callback to collect observations. The callback is called every 60 seconds in a background thread. The up-down counter is a cumulative metric that represents a single numerical value that can be adjusted up or down. ```py from opentelemetry.metrics import CallbackOptions, Observation import logfire logfire.configure() items = [] def inventory_callback(options: CallbackOptions): yield Observation(len(items)) logfire.metric_up_down_counter_callback( name='store.inventory', description='Number of items in the inventory', callbacks=[inventory_callback], ) ``` See the [Opentelemetry documentation](https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-updowncounter) about asynchronous up-down counters. Args: name: The name of the metric. callbacks: A sequence of callbacks that return an iterable of [Observation](https://opentelemetry-python.readthedocs.io/en/latest/api/metrics.html#opentelemetry.metrics.Observation). unit: The unit of the metric. description: The description of the metric. N)r!create_observable_up_down_counterrRs rmetric_up_down_counter_callback'Logfire.metric_up_down_counter_callback[ sR 55dtYrc6URR"U6 g)zPrevent spans and metrics from being created for the given OpenTelemetry scope names. To get the scope name of a span/metric, check the value of the `otel_scope_name` column in the Logfire database. N)rsuppress_scopes)rscopess rr_Logfire.suppress_scopes s $$f-rc ^^[5mSUU4SjjnURR5RU"5S9 U"5nU(dgU(a*URR U5 U"5nU(dgURR5 U"5nU(dgU(a*UR R U5 U"5nU(dgUR RU5 U"5nU(dgU"5S:$)azShut down all tracers and meters. This will clean up any resources used by the tracers and meters and flush any remaining spans and metrics. Args: timeout_millis: The timeout in milliseconds. flush: Whether to flush remaining spans and metrics before shutting down. Returns: `False` if the timeout was reached before the shutdown was completed, `True` otherwise. cP>[S[T[5T- S-- 55$)Nri)maxintr )startrKsr remaining_ms&Logfire.shutdown..remaining_ms s%q#n$/FFGH Hr)rKFr)returnre)r rzget_variable_providershutdownrrJr)rrKflushrg remainingrfs ` @rrkLogfire.shutdown s I I ))+44LN4S N    ! ! - -i 8$I &&( N    , ,Y 7$I %%i0 N ~!!r)r>cgrrx)rrdefaultr>s rvar Logfire.var srcgrrx)rrtyperpr>s rrqrr sr)rtr>c^SSKJnJn Uc:U"U5(a [S5e[ [ [ UR5nOUnSSKnURSU5(d[SUS35eXR;a[SUS 35eU[ "XXpUS 9n XRU'U $) a^Define a managed variable. Managed variables let you externalize runtime configuration from your code, controlling values from the Logfire UI without redeploying. Use `.get()` on the returned `Variable` to resolve the current value. See the [managed variables guide](https://logfire.pydantic.dev/docs/reference/advanced/managed-variables/) for more details. ```py import logfire logfire.configure() # Simple primitive variable (type inferred from default) feature_enabled = logfire.var('feature_enabled', default=False) # Use the variable with feature_enabled.get(targeting_key='user-123') as resolved: if resolved.value: ... ``` Args: name: Unique identifier for the variable. Must match the name configured in the Logfire UI when using remote variables. type: Expected type for validation and JSON schema generation. Can be a primitive type or a Pydantic model. If not provided, the type is inferred from `default`. Required when `default` is a resolve function. default: Default value used when no remote configuration is found. When `type` is not provided, the type is inferred from this value. Can also be a callable with `targeting_key` and `attributes` parameters (requires `type` to be set explicitly). description: Optional human-readable description of what the variable controls. r)rfis_resolve_functionNzWhen `default` is a resolve function (callable with targeting_key and attributes parameters), `type` must be provided to specify the variable value type.z^[a-zA-Z_][a-zA-Z0-9_]*$zInvalid variable name 'zq'. Variable names must be valid Python identifiers (letters, digits, and underscores, not starting with a digit).zA variable with name 'zE' has already been registered. Each variable must have a unique name.)rprtlogfire_instancer>) logfire.variables.variablerfrvr8rrrtr9rematchrr) rrrtrpr>rfrvtpryvariables rrqrr sV M <"7++Rd1gw001BBxx3T::)$0..  ?? "(.st A;t2bmn (rc8URR5 g)a Clear all registered variables from this Logfire instance. This removes all variables previously registered via [`var()`][logfire.Logfire.var], allowing them to be re-registered. This is primarily intended for use in tests to ensure a clean state between test cases. N)rclearrs rvariables_clearLogfire.variables_clear s rcH[URR55$)z8Get all variables registered with this Logfire instance.)listrvaluesrs r variables_getLogfire.variables_get" sDOO**,--rdry_runyesstrictc|UcUR5nURR5nURXX4S9$)a=Push variable definitions (metadata only) to the configured variable provider. This method syncs local variable definitions with the provider: - Creates new variables that don't exist in the provider - Updates JSON schemas for existing variables if they've changed - Warns about existing label values that are incompatible with new schemas The provider is determined by the Logfire configuration. For remote providers, this requires proper authentication (via VariablesOptions or LOGFIRE_API_KEY). Args: variables: Variable instances to push. If None, all variables registered with this Logfire instance will be pushed. 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. Returns: True if changes were applied (or would be applied in dry_run mode), False otherwise. Example: ```python import logfire feature_enabled = logfire.var(name='feature_enabled', type=bool, default=False) max_retries = logfire.var(name='max_retries', type=int, default=3) if __name__ == '__main__': # Push all registered variables logfire.variables_push() # Or push specific variables only logfire.variables_push([feature_enabled]) ``` r)rrzrjpush_variables)r variablesrrrproviders rvariables_pushLogfire.variables_push& sAV  **,I;;446&&ys&ZZrcVURR5nURXX4S9$)a?Push variable type definitions to the configured variable provider. Variable types are reusable schema definitions that can be referenced by variables. They help organize and standardize variable schemas across your project. This method syncs local Python types with the provider: - Creates new types that don't exist in the provider - Updates schemas for existing types if they've changed - Shows a diff of changes before applying - Checks if existing variable label values are compatible with the new schemas The provider is determined by the Logfire configuration. For remote providers, this requires proper authentication (via VariablesOptions or LOGFIRE_API_KEY). Args: types: Types to push. Items can be: - A type (name defaults to __name__ or str(type)) - A tuple of (type, name) for explicit naming 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. Returns: True if changes were applied (or would be applied in dry_run mode), False otherwise. Example: ```python import logfire from pydantic import BaseModel class FeatureConfig(BaseModel): enabled: bool = False max_retries: int = 3 timeout_seconds: float = 30.0 class UserSettings(BaseModel): theme: str = 'light' notifications_enabled: bool = True if __name__ == '__main__': # Push type definitions using their class names logfire.variables_push_types([FeatureConfig, UserSettings]) # Or push with explicit names logfire.variables_push_types( [ (FeatureConfig, 'my-feature-config'), (UserSettings, 'my-user-settings'), ] ) ``` r)rzrjpush_variable_types)rrrrrrs rvariables_push_typesLogfire.variables_push_typesW s-@;;446++E+[[rc~UcUR5nURR5nURU5$)aValidate that provider-side variable label values match local type definitions. This method fetches the current variable configuration from the provider and validates that all label values can be deserialized to the expected types defined in the local Variable instances. Args: variables: Variable instances to validate. If None, all variables registered with this Logfire instance will be validated. Returns: A ValidationReport containing any errors found. Use `report.is_valid` to check if validation passed, and `report.format()` to get a human-readable summary. Example: ```python import logfire feature_enabled = logfire.var(name='feature_enabled', type=bool, default=False) max_retries = logfire.var(name='max_retries', type=int, default=3) if __name__ == '__main__': # Validate all registered variables logfire.variables_validate() # Or validate specific variables only report = logfire.variables_validate([feature_enabled]) assert report.is_valid ``` )rrzrjvalidate_variables)rrrs rvariables_validateLogfire.variables_validate s<D  **,I;;446**955rmergemoderrcVURR5nURXX4S9$)aPush a VariablesConfig to the configured provider. This method pushes a complete VariablesConfig (including labels and rollouts) to the provider. It's useful for: - Pushing configs generated or modified locally - Pushing configs read from files - Partial updates (merge mode) or full replacement (replace mode) Args: config: The VariablesConfig to sync. mode: 'merge' updates/creates only variables in config (leaves others unchanged). 'replace' makes the server match the config exactly (deletes missing variables). dry_run: If True, only show what would change without applying. yes: If True, skip confirmation prompt. Returns: True if changes were applied (or would be applied in dry_run mode), False otherwise. Example: ```python skip="true" import logfire from logfire.variables import VariablesConfig # Push config to server logfire.variables_push_config(config) # Or merge just a subset of variables logfire.variables_push_config(config, mode='merge') ``` r)rzrj push_config)rrzrrrrs rvariables_push_configLogfire.variables_push_config s-L;;446##Fw#PPrcVURR5nUR5$)aPull the current variable configuration from the provider. This method fetches the complete configuration from the provider, useful for generating local copies of the config that can be modified. Returns: The current VariablesConfig from the provider. Example: ```python skip="true" import logfire # Pull config from the provider config = logfire.variables_pull_config() print(config.model_dump_json(indent=2)) ``` )rzrj pull_config)rrs rvariables_pull_configLogfire.variables_pull_config s%$;;446##%%rcXUcUR5nSSKJn UR"U5$)aBuild a VariablesConfig from registered Variable instances. This creates a minimal config with just the name, schema, and example for each variable. No labels or versions are created - use this to build a template config that can be edited. Args: variables: Variable instances to include. If None, uses all registered variables. Returns: A VariablesConfig with minimal configs for each variable. Example: ```python skip="true" import logfire feature_enabled = logfire.var(name='feature_enabled', type=bool, default=False) max_retries = logfire.var(name='max_retries', type=int, default=3) # Build config from registered variables config = logfire.variables_build_config() print(config.model_dump_json(indent=2)) ``` r)rg)rlogfire.variables.configrgfrom_variables)rrrgs rvariables_build_configLogfire.variables_build_config s,6  **,I<--i88r)rrrrrr) rzr)r{z float | Noner| Sequence[str]r}boolr~r0riNone)rir))rizMapping[str, Any])rirA)rir?)rirC)rrrirC)rr0rdict[str, Any]rSequence[str] | Noner str | NonerzLevelName | int | Noner3Sequence[tuple[SpanContext, otel_types.Attributes]]rrrir)rr0rotel_types.Attributesrrrir) rr0r$dict[str, otel_types.AttributeValue]rrrrrir) rr0rrrExcInforrrir)rr0rrrrrzLevelName | Nonerrrrrrrirr)rzLiteralString | Nonerrrbool | Iterable[str]rrr rr!rriz*Callable[[Callable[P, R]], Callable[P, R]])r(Callable[P, R]rir)rz%Callable[P, R] | LiteralString | Nonerrrrrrr rr!rriz;Callable[[Callable[P, R]], Callable[P, R]] | Callable[P, R])NNFN)r<LevelName | intrr0rzdict[str, Any] | Noner|rrrr} bool | Nonerir)r|r0rirv)r{floatrirv)r|rr}rrFrrirv)i )rKrerir)rTzEvaluationReport[Any, Any, Any]rir)g?)rZrriAbstractContextManager[None])r`z1Sequence[str] | Callable[[AutoTraceModule], bool]r_rr]z"Literal['error', 'warn', 'ignore']rir)rhzNSyncTemplate | AsyncTemplate | type[SyncTemplate] | type[AsyncTemplate] | Nonerir)rjrrir)rir)allrxrx)rwr*rx Iterable[str]ryrrir)rhzpydantic_ai.Agent | NonerrrrrLiteral[1, 2, 3] | Noner$Literal['attributes', 'logs'] | Nonerrrir)rhpydantic_ai.models.Modelrrrrrrrrrrrir)rhz3pydantic_ai.Agent | pydantic_ai.models.Model | Nonerrrrrrrrrrrizpydantic_ai.models.Model | None)rrMrrrzMCallable[[Request | WebSocket, dict[str, Any]], dict[str, Any] | None] | Nonerzstr | Iterable[str] | Nonerrrrrrrir)rzZopenai.OpenAI | openai.AsyncOpenAI | type[openai.OpenAI] | type[openai.AsyncOpenAI] | Nonerrr)SemconvVersion | Sequence[SemconvVersion]rir)rir)rzanthropic.Anthropic | anthropic.AsyncAnthropic | anthropic.AnthropicBedrock | anthropic.AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[anthropic.AnthropicBedrock] | type[anthropic.AsyncAnthropicBedrock] | Nonerrrrrir)rr)rrrir)rz httpx.ClientrrrrrrrrrHttpxRequestHook | NonerHttpxResponseHook | Nonerrrir)rzhttpx.AsyncClientrrrrrrrrr/HttpxRequestHook | HttpxAsyncRequestHook | Noner1HttpxResponseHook | HttpxAsyncResponseHook | Nonerrrir)rrrrrrrrrrrrrrrHttpxAsyncRequestHook | NonerHttpxAsyncResponseHook | Nonerrrir)rz'httpx.Client | httpx.AsyncClient | Nonerrrrrrrrrrrrrrrrrrrir)FNNNN)rrrrrz4Callable[[trace_api.Span, HttpRequest], None] | NonerzBCallable[[trace_api.Span, HttpRequest, HttpResponse], None] | Nonerrrrrir)NNN) rrrz7Callable[[Span, requests.PreparedRequest], None] | NonerzJCallable[[Span, requests.PreparedRequest, requests.Response], None] | Nonerrrir)rz&PsycopgConnection | Psycopg2Connectionrrrir)NFN) rz2None | Literal['psycopg', 'psycopg2'] | ModuleTyperrrPsycopgCommenterOptions | Nonerrrir) rrrrrrrrrir)rrNrrrrrzFlaskCommenterOptions | NonerrrzFlaskRequestHook | NonerzFlaskResponseHook | Nonerrrir)rrYrrrrrzServerRequestHook | NonerzClientRequestHook | NonerzClientResponseHook | Nonerrrir)FF) rrhrrrrrzUnpack[ASGIInstrumentKwargs]rirh)FNN) rrJrrrzWSGIRequestHook | NonerzWSGIResponseHook | NonerrrirJ)rrrrrrrrrzAiohttpClientRequestHook | Nonerz AiohttpClientResponseHook | Nonerrrir) rzAsyncEngine | Engine | Nonerz%Iterable[AsyncEngine | Engine] | Nonerrrz!SQLAlchemyCommenterOptions | Nonerrrir)r rprrrirp)r%rkr&z'Callable[[LambdaEvent], Context] | Nonerrrir)FNNN) r+rrz2Callable[[Span, CommandStartedEvent], None] | Nonerz4Callable[[Span, CommandSucceededEvent], None] | Noner,z1Callable[[Span, CommandFailedEvent], None] | Nonerrrir) r+rrzRedisRequestHook | NonerzRedisResponseHook | Nonerrrir)r rmrrrirm)Nbasic)rzzSystemMetricsConfig | Noner:SystemMetricsBaserir)rr0r=r0r>r0rir)rr0r=r0r>r0rir)rr0r=r0r>r0riGauge)rr0r=r0r>r0rir) rr0rSzSequence[CallbackT]r=r0r>r0rir)r`r0rir)i0uT)rKrerlrrir)rr0rprtr>rri Variable[T]) rr0rtztype[T]rpT | ResolveFunction[T]r>rrir) rr0rtztype[T] | Nonerprr>rrir)rizlist[Variable[Any]]) rlist[Variable[Any]] | Nonerrrrrrrir) rz+Sequence[type[Any] | tuple[type[Any], str]]rrrrrrrir)rrrire) rzrgrzLiteral['merge', 'replace']rrrrrir)rirg)rrrirg)^r: __module__ __qualname____firstlineno____doc__r(rpropertyrzrr rrrrrrrINTERNALrrrrrrrrrr rrrrr9rrArDr@rJrVr[r'rcrfrlrprrrrrrrrrrrrrrrrrrr r rrrrr$r*r0r4r8rBrFrJrNrTrXr\r_rkrqrrrrrrrr__static_attributes__rxrrrvrvsW! !.$(  #77" 7  7  77 7 992211II6655 '+!%)-FH'00EE#E $ E  E'EDEE EN %IZhtw 0'+" TT $ T  TT TJ'+" TT $ T  TT TJ'+" SS $ S  SS SJ'+" UU $ U  UU UJ'+" S S $ S  S S  SD D'+" TT $ T  TT TJ'+" TT $ T  TT TJ'+! TT $ T  TT T:'+!%#'FH'00. . $ .  . !. D. . .  . `.2" !%-1# %" *"  " + "  " " "  4" " H    "?C' !%-1# %' ;'  ' + '  ' ' '  E' Z-1%)!#'u!u!u!* u! # u!  u!!u! u!n-. (!#'*.   !  (    > 8Z >,FM &vB&v &v !C &v  &vPSei (a (  (@D5 1(.3!#!# / */ /  /  / b)-  /3'++/;?  %  !,  % ) 9      /3'++/;? ' % ' !, ' % ') '9 ' ' " ' 'DH4 /3'++/;?4 @4 !, 4 % 4 )4 94 4  )4 t!&48$)!H H  H $ H 2H "H H !$!H " &#H ` Z 04=>Z Z )-Z ;Z  &Z x 20 a 04=>a  a )-a ;a &!a F0 + (&.   " %%*&+0426      #  $ . 0      " %%*&+HLKO !     #  $ F I      " %%*&+0426;?=A      #  $ . 0 9 ;     ";?6 $( %%*&+HLKO;?=A6 76 ! 6  6 # 6  $6 F6 I6 96 ;6 6  6 p :!&04MQ\`$( 5 5 #.5 K 5 Z 5 " 5 5  5 r%)PTdh  ! N b      :tt NR!&<@ J:     #!&<@ Q Q Q: Q  Q  QL!&!%:>$(0426- -  -  - 8 - "- .- 0- -  - f!&$)8<8<:>* *  * " * 6 * 6* 8* *  * ^!&$) % % % " % / %  % T!&/315 ' ' ' - ' / '  '  ' X$( %%*&+8<:> !   #  $  6 8    > (/39=!&?C " +" 7"  " = "  "  " Hr,LP % "I     @#(KONRIM " " I" L " G "  "  " L#(0426   . 0      B 6T[=0=?P= =$8:bC<:.D ssmrViV]9>>'Qmrs#%F) r_otlp_attributes_tracer_json_schema_propertiesrrr_added_attributesrr)rrrtracerrrrs rrLogfireSpan.__init__7 sH$ / '=$smrss #!&-1 15 rc.[URU5$r)getattrr)rrs r __getattr__LogfireSpan.__getattr__M s4::t, ,rcURbgURRURURUR UR S9Ulg)N)rrrkind)rrrrrrrrs r_startLogfireSpan._startP sH :: ! \\,,,,++ -  rc>URbgURnSo!ULo3(d[R"SU4SX45S[R "5;d[R "U5(a[R"U5OS[R"U5[R"U5S.-nSSU0-n[[R"U55eS=n=p2[R"[R"UR55Ulg)N)is not)z1%(py2)s {%(py2)s = %(py0)s._span } is not %(py5)sr)py0py2py5zassert %(py7)spy7)rr @pytest_ar_call_reprcompare @py_builtinslocals_should_repr_global_name _safereprAssertionError_format_explanationrrrr)r @py_assert1 @py_assert4 @py_assert3 @py_format6 @py_format8s r_attachLogfireSpan._attach[ s ;; " zz%%%%%%%z%%%%%%t%%%%t%%%z%%%%%%%%%%!(()F)Ftzz)RS rcFUR5 UR5 U$r)rrrs rrLogfireSpan.__enter__b s   rc"UR(aURR5(dgUR(a3URR[[ UR 55 URR5 gr)rr3r set_attributer+r<rr;rs r_endLogfireSpan._endg sWzz!8!8!:!:   ! ! JJ $ $%?AWX\XtXtAu v rcnURcg[R"UR5 SUlgr)rrrrs r_detachLogfireSpan._detacho s( ;;  4;;' rcUR5 UR(aNURR5(a/[U[5(aURR USS9 UR 5 g)NT)escaped)rrr3r5r6r7rrs rrLogfireSpan.__exit__u sP  ::$**1133 9m8\8\ JJ ' ' 4 ' @ rc.UR[S5$r)_get_attributer.rs rmessage_templateLogfireSpan.message_template| s""#BDIIrc.UR[S5$Nrx)rr1rs rr|LogfireSpan.tags s""#6;;rc[U[5(aU4nUR[[ [ U555 g)zSet or add tags to the span.N)r5r0_set_attributer1rrHrnew_tagss rr|r$ s4 h $ $ {H /7H7R1STrcBUR[UR5$r)rr-rrs rmessageLogfireSpan.message s""#94??KKrc0UR[U5 gr)r&r-rr*s rr*r+ s 2Gr~rprepare_otlp_attributerrr)rkeyvalue otel_values rrLogfireSpan.set_attribute s^"&,>uce,L$$S)2H2OO **3/ :: ! JJ $ $S 5 "rcXUR5Hup#URX#5 M g)z&Sets the given attributes on the span.N)itemsr)rrr0r1s rset_attributesLogfireSpan.set_attributes s%$**,JC   s *-rNcURc)U=R[R"XS9/- slgURR X5 g)Nr)rrrradd_link)rrrs rr9LogfireSpan.add_link s8 ::  KKINN7RS SK JJ   4rclURc [S5eURRUUUUS9 g)zjRecords an exception as a span event. Delegates to the OpenTelemetry SDK `Span.record_exception` method. NzSpan has not been started)r timestampr)rr|r7)rrrr<rs rr7LogfireSpan.record_exception s= :: :; ; ## ! $ rc`URSL=(a URR5$r)rr3rs rr3LogfireSpan.is_recording s#zz%C$***A*A*CCrc[U5nURcURRU5 gURR U5 g)zSet the log level of this span.N)r6rrrr6)rr<rs r set_levelLogfireSpan.set_level s>*%0 ::   ! ! ( ( 4 JJ % %j 1rcf[URSUR5nURX5$)Nr)rrrget)rr0rprs rrLogfireSpan._get_attribute s)TZZt7L7LM ~~c++rcrURcX RU'gURRX5 g)zSSet an attribute on the span or in the _otlp_attributes if span is not yet created.N)rrr)rr0r1s rr&LogfireSpan._set_attribute s, :: ). ! !# & JJ $ $S 0r) rrrrrrrrr)rr0rrrrCrr;rrrrrir)rr0rir)rirr)rirriztuple[str, ...]r(rrirrir0r*r0)r0r0r1rrir)rrrirr)rrrrrir)NNF) rr6rrr<z int | Nonerrrirrir)r<r)r0r0rprrir)r:rrrrrrr rrFrrrrrrrr r|setterr*rr6r9r7r3rArr&rrxrrrr6 s'//66>6 6 !5 6 C 66 6(  -  TT    JJ<< [[UU LL ^^== 6 6+ 5-1 $    *       *D22,1rrc\rSrSrSrSSjrSSjrSSjrSSjr\ SSj5r \ SSj5r \ RSS j5r \ SS j5r \ RSS j5r SS jrS rg)ri aImplements the same methods as `LogfireSpan` but does nothing. Used in place of `LogfireSpan` and `FastLogfireSpan` when an exception occurs during span creation. This way code like: with logfire.span(...) as span: span.set_attribute(...) doesn't raise an error even if `logfire.span` fails internally. If `logfire.span` just returned `None` then the `with` block and the `span.set_attribute` call would raise an error. TODO this should also be used when tracing is disabled, e.g. before `logfire.configure()` has been called. cgrrx)r_args_NoopSpan__kwargss rrNoopSpan.__init__  rcS$)Ncgrrx)rPrQs r&NoopSpan.__getattr__.. s$rrx)r_names rrNoopSpan.__getattr__ s..rcU$rrxrs rrNoopSpan.__enter__ rrcgrrxrs rrNoopSpan.__exit__ rSrcgNr<rxrs rr NoopSpan.message_template rcgr#rxrs rr| NoopSpan.tags rarcgrrxr's rr|rc  rcgr_rxrs rr*NoopSpan.message rarcgrrxr-s rr*rg rercg)NFrxrs rr3NoopSpan.is_recording srrxN)rPrrQrrir)rXr0rir)rirrrJrHrIrKrL)r:rrrrrrrrrr r|rMr*r3rrxrrrr s  /  [[   ^^  rrAttributesValueType)boundclUR5VVs0sHupU[U5_M snn$s snnf)ztPrepare attributes for sending to OpenTelemetry. This will convert any non-OpenTelemetry compatible types to JSON. )r5r/)rr0r1s rrr s6 BLAQAQAS TAS:3C'. .AS TT Ts0c@[U[5(a [U5$[U[5(a=U[:a1[ R "SUS[S3[5 [U5$U$[U[[[45(aU$[U5$)z=Convert a user attribute to an OpenTelemetry compatible type.zInteger value z1 is larger than the maximum OTLP integer size of z[ (64-bits), if you need support for sending larger integers, please open a feature request) r5r r:rer4warningsr UserWarningr0rr)r1s rr/r/ s%!%(( E3   $ $ MM 'XYjXklbb  u: L ECu- . . !%((rc<UR5(dg[U5n[U5=n(a[05nUR=(d 0R [ 5nU(aj[U[5(aU[R"[R5 [R"U5nUR S05nSSS5 URU5 [U5U[ 'UR!U5 g!,(df  NC=f)N properties)r3rr=r;rrDr+r5r0 contextlibsuppressjsonJSONDecodeErrorloadsrr<r6)rrrrexisting_propertiesexisting_json_schema_strexisting_json_schemas rset_user_attributes_on_raw_spanr{1 s     -j9O!B:!NNN226$(OO$9r#>#>?Y#Z # 3KS(Q(Q$$T%9%9:'+zz2J'K$&:&>&>|R&P#; ""#9:6LM`6a23( ;:s ')D  DPR)rrrir)r1rrizotel_types.AttributeValue)rrrrrir) __future__rbuiltinsr_pytest.assertion.rewrite assertionrewriterrsrrur4rocollections.abcrrrr contextvarsrenumr functoolsr r r typingr rrrrrrrropentelemetry.contextrropentelemetry.tracerrropentelemetry.metricsrrrropentelemetry.sdk.tracerrrropentelemetry.utilr otel_typestyping_extensionsr r!rr#r<r% auto_tracer&r'rzr(r) config_paramsr* constantsr+r,r-r.r/r0r1r2r3r4r5r6 formatterr7r8r9 json_encoderr: json_schemar;r<r=r>metricsr?rr@rrArBrCrDutilsrErFrGrHrI wsgiref.typesrJrhttpxrpydantic_ai.models pydantic_airequests django.httprKrLfastapirM flask.apprN(opentelemetry.instrumentation.asgi.typesrOrPrQrRrpydantic_evals.reportingrSpymongo.monitoringrTrUrV sqlalchemyrWsqlalchemy.ext.asynciorXstarlette.applicationsrYstarlette.requestsrZstarlette.websocketsr[$surrealdb.connections.async_templater\#surrealdb.connections.sync_templater]r^rr_AiohttpClientRequestHookr`AiohttpClientResponseHookrraFlaskCommenterOptionsFlaskRequestHookFlaskResponseHookrrbHttpxAsyncRequestHookrcHttpxAsyncResponseHookHttpxRequestHookHttpxResponseHookrPsycopgCommenterOptionsr1RedisRequestHookRedisResponseHookrSQLAlchemyCommenterOptionsrWSGIRequestHookWSGIResponseHookrrdrerfrgr rhrir'rjrkrrlr5rmrnror!rpr9rqrrrSystemMetricsConfigrsr6rrrtrvrrrAttributeValuerkrr/r{r|r}rxrrrs" 77-.   ,')NN6526=05    A", (+ ^] -5qq59aa!20*.B@(  SgXd ACB3K7e!J tT9:G CLQ*9Q*9hT<<&b1,b1J44n35jF_F_A_;`aU)()"cN CLr