go{ddlmZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z m Z mZmZmZmZmZmZmZmZddlmZddlmZddlmZddlmZmZm Z m!Z!ddl"m#Z#m$Z$dd lm%Z%m&Z&dd l'm(Z)dd l*m+Z+m,Z,d d l-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFddlGmHZHmIZIddlJmJZJddlKmLZLddlMmNZNmOZOmPZPmQZQddlRmSZSddlTmUZUddlVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^e rddl(m_Z_ddl`maZaddlbZbddlcZcddldZdddleZeddlfmgZgmhZhddlimjZjdd lkmlZldd!lmmnZnmoZompZpdd"lmqZrdd#lsmtZtmuZumvZvdd$lwmxZxdd%lymzZzdd&l{m|Z|dd'l}m~Z~dd(lmZdd)l*mZd d*lmZmZmZd d+lmZmZmZmZd d,lmZd d-lmZmZd d,lmZd d-lmZmZdd.lmZmZdd/lmZmZdd0lmZdd1lmZmZdd2lmZdd3lmZmZdd4lZmZeeeedfZGd5d6ZGd7d8ZGd9d:e#ZGd;d<Zed=ee e)jff>ZdDd?Z dEd@ZdFdAZe,dBZedCZy)G) annotationsN)cached_property)time) TYPE_CHECKINGAnyCallableContextManagerIterableLiteralSequenceTypeVarUnioncastoverload)Context) CallbackTCounter Histogram UpDownCounter) ReadableSpanSpan) SpanContextTracer)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_NUMBERS NULL_ARGS_KEYOTLP_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)ProxyTracerProviderrecord_exceptionset_exception_status) get_versionhandle_internal_errorslog_internal_erroruniquify_sequence) ModuleType)WSGIApplication) HttpRequest HttpResponse)FastAPI)Flask)ClientRequestHookClientResponseHookServerRequestHook)_Gauge)CommandFailedEventCommandStartedEventCommandSucceededEvent)Engine) AsyncEngine) Starlette)Request) WebSocket)Unpack)CommenterOptions RequestHook ResponseHook)AsyncRequestHookAsyncResponseHookrXrY)rW)rXrY)ASGIAppASGIInstrumentKwargs) LambdaEvent LambdaHandler)MySQLConnection)Psycopg2ConnectionPsycopgConnection)SQLite3Connection)BaseConfig) SysExcInfoc eZdZdZeddddd dYdZedZdZed[d Z ed\d Z ed Z ed]d Z ed]d Z d^dZddddd d_dZd`dZ dadZddd dbdZddd dbdZddd dbdZddd dbdZddd dbdZddd dbdZddd dbdZddd dbdZddddd dcdZe dddddd dedZedfd Z dddddd dgd!Z dh did"Zdjd#Zdkd$Zddddd% dld&Z dmdnd'Z!dodpd(Z"d)d* dqd+Z#d,Z$ dr dsd-Z%ddddd. dtd/Z& dddd0 dud1Z' dddd0 dvd2Z(dwd3Z)eddddddd4 dxd5Z*eddddddd4 dyd6Z*e ddddddddddd7 dzd8Z* ddddddddddd7 d{d9Z*dwd:Z+ d| d}d;Z, d~ dd<Z-edd=Z.e d dd>Z. d dd?Z.ddddddd@ ddAZ/ddddddB ddCZ0 d ddDZ1 d ddEZ2dwdFZ3 d ddGZ4ddddHZ5 dd ddIZ6 d ddJZ7 d ddKZ8ddddLZ9 d ddMZ:dNdNdOddPZ;dNdNdOddQZdNdNdO ddTZ?dNdNdO ddUZ@dNdNdO ddVZAddWZBdddXZCy)LogfirezThe main logfire class.NTlogfire)config sample_ratetags console_log otel_scopec\t||_||_||_||_||_yN)tuple_tags_config _sample_rate _console_log _otel_scope)selfrkrlrmrnros K/var/www/openai/venv/lib/python3.12/site-packages/logfire/_internal/main.py__init__zLogfire.__init__{s.4[  ''%c|jSrq)rtrxs ryrkzLogfire.configs ||r{cl|jjd|jjS)Nz No logs or spans will be created)rtwarn_if_not_initializedget_tracer_providerr}s ry_tracer_providerzLogfire._tracer_providers( ,,-OP||//11r{c6|jjSrq)rtget_meter_providerr}s ry_meter_providerzLogfire._meter_providers||..00r{cV|jj|jtSrq)r get_meterrwrr}s ry_meterzLogfire._meters!##--d.>.>HHr{c&|jdS)NFis_span_tracer _get_tracerr}s ry _logs_tracerzLogfire._logs_tracersu55r{c&|jdS)NTrrr}s ry _spans_tracerzLogfire._spans_tracerst44r{cZ|jj|jt|S)Nr)r get_tracerrwr)rxrs ryrzLogfire._get_tracers/$$//    )0  r{rs _span_name_level_linksc: t}i||}|jjrtjj } nd} t |||jj| \} } }|j| |j| ||t<| |t<t|} t|x} rt| | t<|jxsdt!|xsdz}|rt#|| t$<|j& |j&n| j)t*d}||dk7r || t*<|| jt-|t/|xs|| |j0| |S#t2$rt5t7cYSwxYw)N fstring_framerir)links)r<rtinspect_argumentsinspect currentframef_backr4scrubberupdater)r(prepare_otlp_attributesr9r8r&rsrrrCr,rupopr*r2 LogfireSpanr ExceptionrBNoopSpan)rx msg_template attributesrsrrr stack_infomerged_attributesr log_message extra_attrsotlp_attributesjson_schema_propertiesrmrls ry_spanz Logfire._spans1 ,.J <: < < ||-- ' 4 4 6 = = $ 5N! %%+ 6 2Kl  $ $[ 1   k *AM = >8C 4 556GHO)J:)VV%V>TUk>l :;JJ$"ekr(::D7H7N 34$$0!!$(()CTJ  &;!+;>I :;!&&';F'CD*l""&     :  sE7E::FFc |jj||}t|S#t$rt t cYSwxYw)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. )namer)r start_spanFastLogfireSpanrrBr)rxrrspans ry _fast_spanzLogfire._fast_spansJ  %%00dz0RD"4( (   :  s'*A  A cB |t}t|||jj|t<t |x}rt ||t<|jt||j||S#t$rttcYSwxYw)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)r3rtrr(r9r8r&rrrrrBr)rxrr function_argsrrs ry_instrument_span_with_argsz"Logfire._instrument_span_with_argss  *+J KL1? m]a]i]i]r]r1sJ- .)J=)YY%Y9OPf9g 56   5mD E??44 4   :  sA;A>>BBF)rs _exc_infoc jtd|Dr td|jd||||y)aBLog 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. c3>K|]}|jdyw_N startswith.0ks ry z Logfire.trace..#5*Qq||C */Attribute keys cannot start with an underscore.tracermexc_infoNany ValueErrorlogrxrrsrrs ryrz Logfire.trace48 5*5 5NO O , Sr{c jtd|Dr td|jd||||y)aBLog 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. c3>K|]}|jdywrrrs ryrz Logfire.debug..CrrrdebugrNrrs ryrz Logfire.debug'rr{c jtd|Dr td|jd||||y)aALog 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. c3>K|]}|jdywrrrs ryrzLogfire.info..crrrinforNrrs ryrz Logfire.infoG48 5*5 5NO O z Rr{c jtd|Dr td|jd||||y)aELog 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. c3>K|]}|jdywrrrs ryrz!Logfire.notice..rrrnoticerNrrs ryrzLogfire.noticegs48 5*5 5NO O <%)Tr{c jtd|Dr td|jd||||y)aELog a warning message. ```py import logfire logfire.configure() logfire.warn('This is a warning 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. c3>K|]}|jdywrrrs ryrzLogfire.warn..rrrwarnrNrrs ryrz Logfire.warnrr{c jtd|Dr td|jd||||y)aDLog 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. c3>K|]}|jdywrrrs ryrz Logfire.error..rrrerrorrNrrs ryrz Logfire.errorrr{c jtd|Dr td|jd||||y)aBLog 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. c3>K|]}|jdywrrrs ryrz Logfire.fatal..rrrfatalrNrrs ryrz Logfire.fatalrr{c jtd|Dr td|jd||||y)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. c3>K|]}|jdywrrrs ryrz$Logfire.exception..rrrrrNrrs ry exceptionzLogfire.exceptions4( 5*5 5NO O , Sr{c jtd|Dr td|j||||||S)a Context 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. attributes: The arguments to include in the span and format the message template with. Attributes starting with an underscore are not allowed. c3>K|]}|jdywrrrs ryrzLogfire.span..rrrr)rrr)rxrrsrrrrs ryrz Logfire.spansF> 5*5 5NO Ozz  !   r{) span_name extract_argsallow_generatorcy)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. 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. Nrirxrrrrs ryr5zLogfire.instrument)r{cy)aDecorator 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) ``` Nri)rxfuncs ryr5zLogfire.instrumentHrr{ct|r|j|St|t|j||||S)r)callabler5rrrsrs ryr5zLogfire.instrumentXs?: L !$4??$\2 2$djj 1<LZijjr{ct5t}|xsi}i||}|jtdx} d} |jj ret j} | jjjtjjjk(r | j} t|||jj| \} } }| r7|j!| i|| }nt#| x} |t<t#|}t%|} t&dit)|t*|t| i| } t-|x} rt/| | t0<|j2t5|xsdz}|rt7|| t8<|j: |j:n| jt<d}||dk7r || t<<| |j>s n|s d| t@<|jjBjE}|jFjI|| |}|r|durtKjL}tO|t4r|d}tO|tPr,tS||| tTtVdk\r1tY||n$|"t[d |j\j^|ja|dddy#1swYyxYw) aLog 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`. NrrrirT)r start_timerzInvalid type for exc_info: )1rAr<rr(rtrrrrf_code co_filenamerhr__code__r4rrstrrr+r2r)r9r8r&rsrrrCr,rur*rvr-advancedns_timestamp_generatorrrsysr isinstance BaseExceptionr>r'r.r? TypeError __class____name__end)rxlevelrrrmrrnrrmsgrrrrrlrrs ryrz Logfire.logys<$ %,.J#)rJ <: < < !~~&>'++BVBVBbBbb)6(<(< 1J %LL))"/ 2.[, %,,[9"?J!>+!>JCFc(J'(>?"<0 56GHO(%&u-0&  " O*K:)VV%V>TUk>l :;::djb 11D7H7N 34$$0!!$(()CTJ  &;!+;>I :;)4)+Ft''   OWWjVkLl   r{c8|jj|S)zForce flush all spans and metrics. Args: timeout_millis: The timeout in milliseconds. Returns: Whether the flush of spans was successful. )rt force_flush)rxtimeout_milliss ryr zLogfire.force_flush3s||''77r{c.tj||S)aLog 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)rx slow_durations rylog_slow_async_callbacksz Logfire.log_slow_async_callbacks>s((}==r{r)check_imported_modulesc"t||||y)a;Install 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")rxmodulesrrs ryr"zLogfire.install_auto_tracingOsL T7CYhtur{c:|jjdy)Nz#Instrumentation will have no effect)rkrr}s ry,_warn_if_not_initialized_for_instrumentationz4Logfire._warn_if_not_initialized_for_instrumentationws ++,QRr{c |dk7r0ddl}t|jtdkr tdddlm}m}t|tr|h}t|tr|h}|||t|t|y)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) pydanticr@ __version__ RuntimeErrorlogfire.integrations.pydanticrrrrset)rxrrrrrrs ryinstrument_pydanticzLogfire.instrument_pydanticzsz4 U? 8//0;w3GG"#Z[[\ gs #iG gs #iG # G G   r{capture_headersrequest_attributes_mapper excluded_urlsrecord_send_receivec Lddlm}|j|||f||||d|S)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. 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.fastapir*r)rxappr%r&r'r(opentelemetry_kwargsr*s ryr*zLogfire.instrument_fastapisDt = 99;!   ,&?' 3  #  r{)suppress_other_instrumentationc ddl}ddlm}ddlm}m}m}|j|||xs|j|jf|d|||S)uInstrument an OpenAI client so that spans are automatically created for each request. 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 import logfire import openai 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. Returns: A context manager that will revert the instrumentation when exited. Use of this context manager is optional. rNrinstrument_llm_providerget_endpoint_configis_async_client on_responseOpenAI) openai'integrations.llm_providers.llm_providerr1!integrations.llm_providers.openair3r4r5rr6 AsyncOpenAI)rx openai_clientr.r7r1r3r4r5s ryinstrument_openaizLogfire.instrument_openaisSt Thh 99;&   @fmmV-?-?@ *      r{c ddl}ddlm}m}m}ddlm}|j|||xs.|j|j|j|jf|d|||S)aInstrument 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 import logfire import anthropic 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. Returns: A context manager that will revert the instrumentation when exited. Use of this context manager is optional. rNrr2r0 Anthropic) anthropic$integrations.llm_providers.anthropicr3r4r5r8r1rr>AsyncAnthropicAnthropicBedrockAsyncAnthropicBedrock)rxanthropic_clientr.r?r3r4r5r1s ryinstrument_anthropiczLogfire.instrument_anthropic<so| kkT 99;&   ##((**//  +      r{c ddlm}|j|di|jj |jj d|S)zWInstrument the `asyncpg` module so that spans are automatically created for each query.r)instrument_asyncpgtracer_providermeter_providerri)integrations.asyncpgrGrrtrr)rxkwargsrGs ryrGzLogfire.instrument_asyncpgsR< 99;! #'<<#C#C#E"&,,"A"A"C  r{) capture_allr%capture_request_bodycapture_response_body request_hook response_hookc yrqri rxclientrMr%rNrOrPrQrLs ryinstrument_httpxzLogfire.instrument_httpxr{c yrqrirSs ryrUzLogfire.instrument_httpxrVr{rMr%rNrOrPrQasync_request_hookasync_response_hookc yrqri) rxrTrMr%rNrOrPrQrYrZrLs ryrUzLogfire.instrument_httpxsr{c Tddlm} |j| ||f|||||||| d| S)aInstrument 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. 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)rUrX)integrations.httpxrUr) rxrTrMr%rNrOrPrQrYrZrLrUs ryrUzLogfire.instrument_httpxsPL 9 99;    $+!5"7%'1 3    r{c ddlm}|j|di|jj |jj d|S)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. Args: **kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` method, for future compatibility. r)instrument_celeryrHri)integrations.celeryr_rrtrr)rxrLr_s ryr_zLogfire.instrument_celerysT ; 99;  #'<<#C#C#E"&,,"A"A"C  r{c ddlm}|j|d|||||d|jj |jj d|S)aInstrument `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)r%is_sql_commentor_enabledrPrQr'rHri)integrations.djangorbrrtrr)rxr%rcrPrQr'rLrbs ryrbzLogfire.instrument_djangoskN ; 99;  +%=%''  $(<<#C#C#E"&,,"A"A"C  r{c ddlm}|j|d|||d|jj |jj d|S)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)r'rPrQrHri)integrations.requestsrfrrtrr)rxr'rPrQrLrfs ryrfzLogfire.instrument_requestsLsd ? 99;"  '%'  $(<<#C#C#E"&,,"A"A"C  r{c yrqri)rxconn_or_modulerLs ryinstrument_psycopgzLogfire.instrument_psycopgisqtr{c yrqri)rxrienable_commentercommenter_optionsrLs ryrjzLogfire.instrument_psycopglsr{c xddlm}|j|r|jd|xsid||fd|i|S)agInstrument 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)rjT)rlrmri)integrations.psycopgrjrr)rxrirlrmrLrjs ryrjzLogfire.instrument_psycopgusC6 = 99;  MMtJ[Ja_ab c!$P~PPPr{r%rlrm exclude_urlsrPrQc ddlm} |j| |f||||||d|jj |jj d|S)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). exclude_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_flaskrprH)integrations.flaskrsrrtrr) rxr,r%rlrmrqrPrQrLrss ryrszLogfire.instrument_flasksp: 9 99;   +-/%%'  $(<<#C#C#E"&,,"A"A"C  r{)r%r(server_request_hookclient_request_hookclient_response_hookc Nddlm}|j|||f|||||d|S)aInstrument `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)r(r%rurvrw)integrations.starletteryr) rxr,r%r(rurvrwrLrys ryryzLogfire.instrument_starlettesG< A 99;#    !4+ 3 3!5    r{c Hddlm}|j|||f||d|S)a_Instrument `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)r(r%)integrations.asgir|r)rxr,r%r(rLr|s ryr|zLogfire.instrument_asgis=8 7 99;   !4+     r{c ddlm}|j||f|||d|jj |jj d|S)akInstrument `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)r%rPrQrH)integrations.wsgirrrtrr)rxr,r%rPrQrLrs ryrzLogfire.instrument_wsgisg4 7 99;   +%'  $(<<#C#C#E"&,,"A"A"C  r{c @ddlm}|j||fi|S)aInstrument 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)integrations.aiohttp_clientrr)rxrLrs ryrz!Logfire.instrument_aiohttp_clientBs$ K 99;(888r{c ddlm}|j|d|||xsid|jj |jj d|S)a#Instrument 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, or `None` to instrument all engines. 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)enginerlrmrHri)integrations.sqlalchemyrrrtrr)rxrrlrmrLrs ryrzLogfire.instrument_sqlalchemyNsj& C 99;$  -/52  $(<<#C#C#E"&,,"A"A"C  r{c zddlm}|j|dd|id|jj i|S)aInstrument 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_sqlite3connrIri)integrations.sqlite3rrrtr)rxrrLrs ryrzLogfire.instrument_sqlite3os? = 99;!qtq0A4<TVe^<=  &&(>TVe^<=    , ,Y 7>TVe^<=  %%i0.00r{) rkr$rlz float | Nonerm Sequence[str]rnboolrorreturnNone)rr$)rr=)rr;)rr)rrrr)rrrdict[str, Any]rsSequence[str] | Noner str | NonerzLevelName | int | Noner3Sequence[tuple[SpanContext, otel_types.Attributes]]rr)rrrotel_types.Attributesrr)rrr$dict[str, otel_types.AttributeValue]rrrr) rrrsrrExcInforrrr)rrrsrrrrzLevelName | Nonerrrrrrrq) rzLiteralString | Nonerrrbool | Iterable[str]rrrz*Callable[[Callable[P, R]], Callable[P, R]])rCallable[P, R]rr) rz%Callable[P, R] | LiteralString | Nonerrrrrrrz;Callable[[Callable[P, R]], Callable[P, R]] | Callable[P, R])NNFN)rLevelName | intrrrzdict[str, Any] | Nonermrrrrn bool | Nonerr)rmrrrh)rlfloatrrh) rmrr int | Nonernrrrrrh)i )r intrr)g?)rrrContextManager[None])rz1Sequence[str] | Callable[[AutoTraceModule], bool]rrrz"Literal['error', 'warn', 'ignore']rr)allriri)rr%r Iterable[str]rrrr)r,rHr%rr&zMCallable[[Request | WebSocket, dict[str, Any]], dict[str, Any] | None] | Noner'zstr | Iterable[str] | Noner(rr-rrr)r;zZopenai.OpenAI | openai.AsyncOpenAI | type[openai.OpenAI] | type[openai.AsyncOpenAI] | Noner.rrr)rDzanthropic.Anthropic | anthropic.AsyncAnthropic | anthropic.AnthropicBedrock | anthropic.AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[anthropic.AnthropicBedrock] | type[anthropic.AsyncAnthropicBedrock] | Noner.rrr)rLrrr)rTz httpx.ClientrMrr%rrNrrOrrPHttpxRequestHook | NonerQHttpxResponseHook | NonerLrrr)rTzhttpx.AsyncClientrMrr%rrNrrOrrP/HttpxRequestHook | HttpxAsyncRequestHook | NonerQ1HttpxResponseHook | HttpxAsyncResponseHook | NonerLrrr)rTrrMrr%rrNrrOrrPrrQrrYHttpxAsyncRequestHook | NonerZHttpxAsyncResponseHook | NonerLrrr)rTz'httpx.Client | httpx.AsyncClient | NonerMrr%rrNrrOrrPrrQrrYrrZrrLrrr)FNNNN)r%rrcrrPz4Callable[[trace_api.Span, HttpRequest], None] | NonerQzBCallable[[trace_api.Span, HttpRequest, HttpResponse], None] | Noner'rrLrrr)NNN) r'rrPz7Callable[[Span, requests.PreparedRequest], None] | NonerQzJCallable[[Span, requests.PreparedRequest, requests.Response], None] | NonerLrrr)riz&PsycopgConnection | Psycopg2ConnectionrLrrr)NFN) riz2None | Literal['psycopg', 'psycopg2'] | ModuleTyperlrrmPsycopgCommenterOptions | NonerLrrr) rirrlrrmrrLrrr)r,rIr%rrlrrmzFlaskCommenterOptions | NonerqrrPzFlaskRequestHook | NonerQzFlaskResponseHook | NonerLrrr)r,rSr%rr(rruzServerRequestHook | NonervzClientRequestHook | NonerwzClientResponseHook | NonerLrrr)FF) r,r\r%rr(rrLzUnpack[ASGIInstrumentKwargs]rr\)FNN) r,rEr%rrPzWSGIRequestHook | NonerQzWSGIResponseHook | NonerLrrrE) rzAsyncEngine | Engine | Nonerlrrmz!SQLAlchemyCommenterOptions | NonerLrrr)rrcrLrrrc)rr_rz'Callable[[LambdaEvent], Context] | NonerLrrr)FNNN) rrrPz2Callable[[Span, CommandStartedEvent], None] | NonerQz4Callable[[Span, CommandSucceededEvent], None] | Nonerz1Callable[[Span, CommandFailedEvent], None] | NonerLrrr) rrrPzRedisRequestHook | NonerQzRedisResponseHook | NonerLrrr)rr`rLrrr`)Nbasic)rkzSystemMetricsConfig | NonerSystemMetricsBaserr)rrrrrrrr)rrrrrrrr)rrrrrrrGauge)rrrrrrrr) rrrzSequence[CallbackT]rrrrrr)rrrr)i0uT)r rrrrr)Dr __module__ __qualname____doc__r#rzpropertyrkrrrrrrrrrrrrrrrrrrrrr5rrrrr rr"rr#r*r<rErGrUr_rbrfrjrsryr|rrrrrrrrrrrrrrrrrrrir{ryrhrhxs ! !.$(  # & &" &  &  & &  &2211II6655 '+!%)-FH;;#; $ ;  ;';D; ;z %IZh 0'+" TT $ T  TT TJ'+" TT $ T  TT TJ'+" SS $ S  SS SJ'+" UU $ U  UU UJ'+" SS $ S  SS SJ'+" TT $ T  TT TJ'+" TT $ T  TT TJ'+! TT $ T  TT T:'+!%#'FH( ( $ (  ( !( D( (  ( T.2 !%-1 %  *   +     4  <    "?Ck!%-1 % k;k k + k  k EkJ-1%)!#'m!m!m!* m! # m!  m!!m! m!^-. (!#'#'*. ! ! ! ! ! ! ( !  ! F 8>,FM &vB&v &v !C &v  &vPS .3!#!# / */ /  /  / j!&48$)E E  E $ E 2E "E !$E !E Z H 04H H )-H  H l R 04R  R )-R  R h   " %%*&+0426      #  $ . 0      " %%*&+HLKO !     #  $ F I      " %%*&+0426;?=A      #  $ . 0 9 ;     ";?5 " %%*&+HLKO;?=A5 75  5  5 # 5  $5 F5 I5 95 ;5 5  5 n .!&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 ' ' ' - ' / '  '  ' R 9/3!&?C  +  =      Br,LP % "I     @#(KONRIM " " I" L " G "  "  " L#(0426   . 0      B 6T[=0=?P= =$8:bC<:.Ps(smrViV]_i9>>'jQQmrs$&F) r_otlp_attributes_tracer_json_schema_propertieslistr_added_attributesrr)rxrrtracerrrs ryrzzLogfireSpan.__init__DsK$ / '=$smrss !&%) ,0 r{c.t|j|Srq)getattrr)rxrs ry __getattr__zLogfireSpan.__getattr__Xs4::t, ,r{ct5|jA|jj|j|j |j |_|jj|j7tjtj|j|_ddd|S#1swY|SxYw)N)rrr) rArrrrrrrrrrrrr}s ryrzLogfireSpan.__enter__[s # %zz!!\\44#44++5 JJ "{{")001N1Ntzz1Z[ & & s B+CC c|jy|jJtj|jd|_|jj rpt 5|j r3|jjtt|jddd|jj|||yy#1swY(xYwrq) rrrr is_recordingrAr set_attributer&r8rrrs ryrzLogfireSpan.__exit__is ;;  zz%%%4;;' :: " " $')))JJ,,24J4KgKg4h* JJ  )Y ? %))s &AC  Cc.|jtdSrq)_get_attributer)r}s rymessage_templatezLogfireSpan.message_templateys""#BDIIr{c.|jtdSNri)rr,r}s ryrmzLogfireSpan.tags}s""#6;;r{czt|tr|f}|jtt t |y)zSet or add tags to the span.N)rr_set_attributer,rrrCrxnew_tagss ryrmzLogfireSpan.tagss1 h $ {H /7H7R1STr{cB|jt|jSrq)rr(rr}s rymessagezLogfireSpan.messages""#94??KKr{c0|jt|yrq)rr(rxrs ryrzLogfireSpan.messages 2Guce,L$$S),T-B-BCOZ :: ! JJ $ $S* 5 "r{cX|jD]\}}|j||y)z&Sets the given attributes on the span.N)itemsr )rxrrrs ryset_attributeszLogfireSpan.set_attributess)$**,JC   sE *-r{Nc|j,|xjtj||gz c_y|jj ||y)Nr)rrrradd_link)rxrrs ryr#zLogfireSpan.add_links< ::  KKINN7zRS SK JJ   4r{c|j td|jjsyt|j||||y)zzRecords an exception as a span event. Delegates to the OpenTelemetry SDK `Span.record_exception` method. NzSpan has not been started)r timestampescaped)rr r r>)rxrrr%r&s ryr>zLogfireSpan.record_exceptionsJ :: :; ;zz&&(  JJ !  r{cV|jduxr|jjSrq)rr r}s ryr zLogfireSpan.is_recordings#zz%C$***A*A*CCr{ct|}|j|jj|y|jj |y)zSet the log level of this span.N)r2rrrr!)rxrrs ry set_levelzLogfireSpan.set_levels>*%0 ::   ! ! ( ( 4 JJ % %j 1r{cht|jd|j}|j||S)Nr)rrrget)rxrdefaultrs ryrzLogfireSpan._get_attributes+TZZt7L7LM ~~c7++r{ct|j||j|<y|jj||y)zSSet an attribute on the span or in the _otlp_attributes if span is not yet created.N)rrr )rxrrs ryrzLogfireSpan._set_attributes0 :: ).D ! !# & JJ $ $S% 0r{) rrrrrrrr7rrrr)rrrr)rrr)rrrztuple[str, ...]rrrrrrrr)rrrrrr)rrrrrq)rrrrrr)NNF) rrrrr%rr&rrrrr)rr)rrr,rrr)rrrrzrrrrArrrrmsetterrr r!r#r>r r)rrrir{ryrrCso11>1 1 !5 1 C 1 1$  -  @ @JJ<< [[UU LL ^^== 6 6+ 5-1 $    *       4D22,1r{rceZdZdZd dZddZddZddZeddZ eddZ e jddZ edd Z e jdd Z dd Z y )ra?Implements 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. cyrqri)rx_args_NoopSpan__kwargss ryrzzNoopSpan.__init__ r{cdS)Ncyrqri)r6r7s ryz&NoopSpan.__getattr__..s$r{ri)rx_names ryrzNoopSpan.__getattr__s..r{c|Srqrir}s ryrzNoopSpan.__enter__rr{cyrqrirs ryrzNoopSpan.__exit__r8r{cyNrrir}s ryrzNoopSpan.message_templater{cyrrir}s ryrmz NoopSpan.tagsrAr{cyrqrirs ryrmz NoopSpan.tags  r{cyr@rir}s ryrzNoopSpan.message rAr{cyrqrirs ryrzNoopSpan.message rDr{cy)NFrir}s ryr zNoopSpan.is_recording sr{N)r6rr7rrr)r<rrr)rrrr0r.r/r1r2)rrrrrzrrrrrrmr3rr rir{ryrrs  /  [[   ^^  r{rAttributesValueType)boundcTi}|jD]\}}t||||S)z|Prepare attributes for sending to OpenTelemetry. This will convert any non-OpenTelemetry compatible types to JSON. )r r)rrrrs ryrr s4 =?O &&( U?C7) r{cZ|+td|jtg|gz}t}nvt|tr=|t kDr1t jd|dt dtt|}n,|}n)t|tttfr|}n t|}|||<||fS)aConvert a user attribute to an OpenTelemetry compatible type and add it to the given dictionary. Returns the final key and value that was added to the dictionary. The key will be the original key unless the value was `None`, in which case it will be `NULL_ARGS_KEY`. z list[str]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) rr+r/rrr0warningsr UserWarningrrrr6)rrrrs ryrr$ s }+':':="'MNRUQVV  E3  $ $ MM 'XYjXklbb  UJJ ECu- . '. %OC  ?r{c|jsyt|}t|x}rti}|jxsij t }|rct|trStjtj5tj|}|j di}ddd|j|t||t <|j!|y#1swY>xYw)N properties)r rr9r7rr+r&rr contextlibsuppressjsonJSONDecodeErrorloadsrr8r!)rrrrexisting_propertiesexisting_json_schema_strexisting_json_schemas ryset_user_attributes_on_raw_spanrXB s    -j9O!B:!NNN226$(OO$9r#>#>?Y#Z # 3KS(Q$$T%9%9:'+zz2J'K$&:&>&>|R&P#; ""#9:6LM`6a23( ;:s (C22C;PR)rrrr)rrrrrrrz%tuple[str, otel_types.AttributeValue])rrrrrr) __future__rrPrrRrrL functoolsrrtypingrrrr r r r r rrropentelemetry.contextrropentelemetry.tracerrropentelemetry.metricsrrrropentelemetry.sdk.tracerrrropentelemetry.utilr otel_typestyping_extensionsrrversionrrr auto_tracer!r"rkr#r$ config_paramsr% constantsr&r'r(r)r*r+r,r-r.r/r0r1r2 formatterr3r4r5 json_encoderr6 json_schemar7r8r9r:metricsr;rr<rr=r>r?utilsr@rArBrCrD wsgiref.typesrEr?httpxr7requests django.httprFrGfastapirH flask.apprI(opentelemetry.instrumentation.asgi.typesrJrKrLrMrpymongo.monitoringrNrOrP sqlalchemyrQsqlalchemy.ext.asynciorRstarlette.applicationsrSstarlette.requestsrTstarlette.websocketsrUrVrtrWFlaskCommenterOptionsrXFlaskRequestHookrYFlaskResponseHookr]rZHttpxAsyncRequestHookr[HttpxAsyncResponseHookHttpxRequestHookHttpxResponseHookroPsycopgCommenterOptionsrRedisRequestHookRedisResponseHookrSQLAlchemyCommenterOptionsrWSGIRequestHookWSGIResponseHookr}r\r]rr^r_rr`rarbrrcrrdrreSystemMetricsConfigrfrrrrhrrrAttributeValuerHrrrXrYrZrir{ryrs" %    ,')NN6326=05A", (+OO]] -5qq5aa!20*.(  SgXd@C3K7e!J tT9:Gu1u1p=<<&W1,W1t44n35jF_F_A_;`a 9@CLO*<)"cN CLr{