o ie @sUddlZddlZddlmZddlmZddlmZddlZddlm Z ddl m Z ddl m Z ddl mZdd l mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddl m!Z!ddl m"Z"ddl m#Z#ddl m$Z$ddl m%Z%ddl m&Z&ddl'm(Z(ddl)m*Z*ddl)m+Z+ddl)m,Z,ddl)m-Z-ddl)m.Z.ddl)m/Z/dd l)m0Z1dd!l)m2Z2dd"l)m3Z4dd#l)m5Z5dd$l)m6Z6dd%l)m7Z7dd&l)m8Z8dd'l)m9Z9dd(l:m;Z;dd)lm?Z?d+d,l@mAZAe;eBZCd-ZDed-eEd.<d/ZFed/eEd0<d1ZGed1eEd2<d3ZHed3eEd4<d5ZIed5eEd6<d7ZJed7eEd8<d9ZKed9eEd:<d;ZLed;eEd<<d=ZMed=eEd><d?ZNed?eEd@<dAZOedAeEdB<dCZPedCeEdD<dEZQedEeEdF<dGZRedGeEdH<dIeSdJeTeSfdKdLZUeUeFZVeUeGZWeUeHZXeUeIZYeTeOeAeOZgZ[eUeJZ\eUeKZ]eUeLZ^eUeMZ_eUeNZ`eUePZaeUeQZbeUeDZceUeRZdeedMejfZg dldNeTeSdOeheSeSfdPeeSdJeeSfdQdRZidOeheSeSfdSe fdTdUZjdVeSdJekfdWdXZlelZmdYekdJeSfdZd[Znd\eSd]eSdJdfd^d_ZoGd`dadaZpGdbdcdcZqGdddedeZrGdfdgdgZsGdhdidiZte7epe5eqe6ere,ese+etiZuGdjdkdkevZwdS)mN)Literal)Optional)Union)SpanLink)Context)Span)!_get_64_highest_order_bits_as_hex) _get_64_lowest_order_bits_as_int)APPSEC)core)config)telemetry_writer)TELEMETRY_NAMESPACE) AUTO_KEEP) AUTO_REJECT) USER_KEEP)TagsetDecodeError)TagsetEncodeError)TagsetMaxSizeDecodeError)TagsetMaxSizeEncodeError)decode_tagset_string)encode_tagset_values ensure_text)_PROPAGATION_BEHAVIOR_RESTART)_PROPAGATION_STYLE_BAGGAGE)#_PROPAGATION_STYLE_W3C_TRACECONTEXT)BAGGAGE_TAG_PREFIX)DD_TRACE_BAGGAGE_MAX_BYTES)DD_TRACE_BAGGAGE_MAX_ITEMS)HIGHER_ORDER_TRACE_ID_BITS)LAST_DD_PARENT_ID_KEY)MAX_UINT_64BITS)PROPAGATION_STYLE_B3_MULTI)PROPAGATION_STYLE_B3_SINGLE)PROPAGATION_STYLE_DATADOG)W3C_TRACEPARENT_KEY)W3C_TRACESTATE_KEY) get_logger)validate_sampling_decision)w3c_tracestate_add_p)get_wsgi_headerz ot-baggage-_HTTP_BAGGAGE_PREFIXzx-datadog-trace-idHTTP_HEADER_TRACE_IDzx-datadog-parent-idHTTP_HEADER_PARENT_IDzx-datadog-sampling-priorityHTTP_HEADER_SAMPLING_PRIORITYzx-datadog-originHTTP_HEADER_ORIGINb3_HTTP_HEADER_B3_SINGLEz x-b3-traceid_HTTP_HEADER_B3_TRACE_IDz x-b3-spanid_HTTP_HEADER_B3_SPAN_IDz x-b3-sampled_HTTP_HEADER_B3_SAMPLEDz x-b3-flags_HTTP_HEADER_B3_FLAGSzx-datadog-tags_HTTP_HEADER_TAGS traceparent_HTTP_HEADER_TRACEPARENT tracestate_HTTP_HEADER_TRACESTATEbaggage_HTTP_HEADER_BAGGAGEheaderreturncCst|t|gSN) frozensetr-lower)r@rEL/home/ubuntu/.local/lib/python3.10/site-packages/ddtrace/propagation/http.py_possible_headerGsrGaj ^ # Start of string ([a-f0-9]{2})- # 2 character hex version ([a-f0-9]{32})- # 32 character hex trace id ([a-f0-9]{16})- # 16 character hex span id ([a-f0-9]{2}) # 2 character hex sample flag (-.+)? # optional, start of any additional values $ # end of string possible_header_namesheadersdefaultcCs*|D]}||vrt||ddSq|S)Nbackslashreplace)errorsr)rHrIrJr@rErErF_extract_header_valuens rMcontextcCsN|dur#|D]\}}tD]}||r!||t|d|qqdSdSrB)items_POSSIBLE_HTTP_BAGGAGE_PREFIX startswithset_baggage_itemlen)rIrNkeyvaluepossible_prefixrErErF_attach_baggage_to_contextxs rWhex_idcCs t|dS)z7Helper to convert hex ids into Datadog compatible ints.)int)rXrErErF_hex_id_to_dd_id r[dd_idcCs|tkr d|Sd|S)zGHelper to convert Datadog trace/span int ids into lower case hex valuesz{:032x}{:016x})_MAX_UINT_64BITSformat)r]rErErF_dd_id_to_b3_ids  ra metric_name header_stylecCstjtj|dd|ffddS)zRecord telemetry metric for HTTP propagation operations. :param metric_name: The name of the metric to record :param tags: tuple of tag key-value pairs to include with the metric r,rc namespacenamerUtagsN)r add_count_metricrTRACERS)rbrcrErErF_record_http_telemetrys  rjc@seZdZdZedgZeddZedee e fde e fddZ ed d Z ed e d e de fd dZede defddZededee e fddfddZedee e fde efddZdS)_DatadogMultiHeaderaHelper class for injecting/extract Datadog multi header format Headers: - ``x-datadog-trace-id`` the context trace id as a uint64 integer - ``x-datadog-parent-id`` the context current span id as a uint64 integer - ``x-datadog-sampling-priority`` integer representing the sampling decision. ``<= 0`` (Reject) or ``> 1`` (Keep) - ``x-datadog-origin`` optional name of origin Datadog product which initiated the request - ``x-datadog-tags`` optional tracer tags Restrictions: - Trace tag key-value pairs in ``x-datadog-tags`` are extracted from incoming requests. - Only trace tags with keys prefixed with ``_dd.p.`` are propagated. - The trace tag keys must be printable ASCII characters excluding space, comma, and equals. - The trace tag values must be printable ASCII characters excluding comma. Leading and trailing spaces are trimmed. z_dd.p.upstream_servicescCs |dS)Nz_dd.p.)rQrTrErErF_is_valid_datadog_trace_tag_keyr\z3_DatadogMultiHeader._is_valid_datadog_trace_tag_keyrIrAcCstt|ddS)NrJ)rM_POSSIBLE_HTTP_HEADER_TAGS)rIrErErF_get_tags_values z#_DatadogMultiHeader._get_tags_valuecCstzddt|D}W|Sty$ddi}tjd|ddY|Sty9ddi}tjd|ddY|Sw) NcSs*i|]\}}|tjvrt|r||qSrE)rk_X_DATADOG_TAGS_EXTRACT_REJECTrm.0kvrErErF s z5_DatadogMultiHeader._extract_meta.._dd.propagation_errorextract_max_sizez#failed to decode x-datadog-tags: %rTexc_infodecoding_error)rrOrlogwarningrdebug) tags_valuemetarErErF _extract_metas    z!_DatadogMultiHeader._extract_metatrace_id_hob_hex low_64_bitscCst|d|dS)Nr^rY)rZr`)rrrErErF_put_together_trace_idsz*_DatadogMultiHeader._put_together_trace_id upper_64_bitscCsDzt|dkst|ds|stWdSWdSty!YdSw)NrYFT)rSrZislower ValueError)rrErErF_higher_order_is_valids z*_DatadogMultiHeader._higher_order_is_valid span_contextNcCsr|jdus |jdurtd|dStjstj|jvrdS|jt kr4t t |j|t <t |j|jt<nt |j|t <t |j|t<|j}|durPt |j|t<|jdur\t|j|t<tjsfd|jd<dSd|jvrmdSt|j}dd|D}|rz t|tjd|t<Wn)tyd|jd<tjdd d Yntyd |jd<tjdd d Ynwtd t dS) N"tried to inject invalid context %rdisabledrxcSs i|] \}}t|r||qSrE)rkrmrsrErErFrws z/_DatadogMultiHeader._inject..)max_sizeinject_max_sizezfailed to encode x-datadog-tagsTrzencoding_errorcontext_header_style.injected)!trace_idspan_idr}r asm_config_apm_tracing_enabledr PROPAGATION_HEADER_metar_strr r/r_HIGHER_ORDER_TRACE_ID_BITSr0sampling_priorityr1 dd_originrr2r _x_datadog_tags_enabledlistrOr_x_datadog_tags_max_lengthr9rr~rrjr&)rrIr context_metatags_to_encoderErErF_injectsF         z_DatadogMultiHeader._injectc Cstt|}|dur dSzt|}Wn tyd}Ynw|dks%|tkr-td|dStt|dd}tt|}tt |}d}t |}|rLt |}|rut |vru|t }t |retjrdt ||}nd||d<|t =td||syi}z4|durt|}|rt|}tjs|rtj|vrd}n |rtj|vrd}t|pdt|pd|||d WSttfytd |||||YdSw) NrzXInvalid trace id: %r. `x-datadog-trace-id` must be greater than zero and less than 2**640rozmalformed_tid {}rxz>malformed_tid: %s. Failed to decode trace id from http headersrrrrrrzdreceived invalid x-datadog-* headers, trace-id: %r, parent-id: %r, priority: %r, origin: %r, tags:%r)rMPOSSIBLE_HTTP_HEADER_TRACE_IDSrZrr_r}r~POSSIBLE_HTTP_HEADER_PARENT_IDS(POSSIBLE_HTTP_HEADER_SAMPLING_PRIORITIESPOSSIBLE_HTTP_HEADER_ORIGINrkrqrrrr _128_bit_trace_id_enabledrr`r*rrr rr TypeErrorr) rI trace_id_strrparent_span_idroriginrrrrErErF_extract%s           z_DatadogMultiHeader._extract)__name__ __module__ __qualname____doc__rCrr staticmethodrmdictrrrqrrZrboolrrrrrErErErFrks"     ;$rkc@TeZdZdZededeeefddfddZedeeefde efdd Z dS) _B3MultiHeaderaHelper class to inject/extract B3 Multi-Headers https://github.com/openzipkin/b3-propagation/blob/3e54cda11620a773d53c7f64d2ebb10d3a01794c/README.md#multiple-headers Example:: X-B3-TraceId: 80f198ee56343ba864fe8b2a57d3eff7 X-B3-ParentSpanId: 05e3ac9a4f6e3b90 X-B3-SpanId: e457b5a2e4d86bd1 X-B3-Sampled: 1 Headers: - ``X-B3-TraceId`` header is encoded as 32 or 16 lower-hex characters. - ``X-B3-SpanId`` header is encoded as 16 lower-hex characters. - ``X-B3-Sampled`` header value of ``0`` means Deny, ``1`` means Accept, and absent means to defer. - ``X-B3-Flags`` header is used to set ``1`` meaning Debug or an Accept. Restrictions: - ``X-B3-Sampled`` and ``X-B3-Flags`` should never both be set Implementation details: - Sampling priority gets encoded as: - ``sampling_priority <= 0`` -> ``X-B3-Sampled: 0`` - ``sampling_priority == 1`` -> ``X-B3-Sampled: 1`` - ``sampling_priority > 1`` -> ``X-B3-Flags: 1`` - Sampling priority gets decoded as: - ``X-B3-Sampled: 0`` -> ``sampling_priority = 0`` - ``X-B3-Sampled: 1`` -> ``sampling_priority = 1`` - ``X-B3-Flags: 1`` -> ``sampling_priority = 2`` - ``X-B3-TraceId`` is not required, will use ``None`` when not present - ``X-B3-SpanId`` is not required, will use ``None`` when not present rrIrANcCs|jdus |jdurtd|dSt|j|t<t|j|t<|j}|durA|dkr0d|t<n|dkr9d|t<n|dkrAd|t <t dt dS)Nrrrr,1r) rrr}rrar5r6rr7r8rjr$)rrIrrErErFrs   z_B3MultiHeader._injectc Cstt|}|dur dStt|}tt|}tt|}z9d}d}|dur)t|p(d}|dur3t|p2d}d}|durF|dkr@t}n|dkrFt}|dkrLt}t |||dWSt t fyht d||||YdSw)NrrrrrzRreceived invalid x-b3-* headers, trace-id: %r, span-id: %r, sampled: %r, flags: %r)rM"_POSSIBLE_HTTP_HEADER_B3_TRACE_IDS!_POSSIBLE_HTTP_HEADER_B3_SPAN_IDS!_POSSIBLE_HTTP_HEADER_B3_SAMPLEDS_POSSIBLE_HTTP_HEADER_B3_FLAGS_b3_id_to_dd_idrrrrrrr}r)rI trace_id_val span_id_valsampledflagsrrrrErErFrs`  z_B3MultiHeader._extract rrrrrrrrrrrrErErErFrs % $rc@r) _B3SingleHeadera9Helper class to inject/extract B3 https://github.com/openzipkin/b3-propagation/blob/3e54cda11620a773d53c7f64d2ebb10d3a01794c/README.md#single-header Format:: b3={TraceId}-{SpanId}-{SamplingState}-{ParentSpanId} Example:: b3: 80f198ee56343ba864fe8b2a57d3eff7-e457b5a2e4d86bd1-1-05e3ac9a4f6e3b90 Values: - ``TraceId`` header is encoded as 32 or 16 lower-hex characters. - ``SpanId`` header is encoded as 16 lower-hex characters. - ``SamplingState`` header value of ``0`` means Deny, ``1`` means Accept, and ``d`` means Debug - ``ParentSpanId`` header is not used/ignored if sent Restrictions: - ``ParentSpanId`` value is ignored/not used Implementation details: - Sampling priority gets encoded as: - ``sampling_priority <= 0`` -> ``SamplingState: 0`` - ``sampling_priority == 1`` -> ``SamplingState: 1`` - ``sampling_priority > 1`` -> ``SamplingState: d`` - Sampling priority gets decoded as: - ``SamplingState: 0`` -> ``sampling_priority = 0`` - ``SamplingState: 1`` -> ``sampling_priority = 1`` - ``SamplingState: d`` -> ``sampling_priority = 2`` - ``TraceId`` is not required, will use ``None`` when not present - ``SpanId`` is not required, will use ``None`` when not present rrIrANcCs|jdus |jdurtd|dSdt|jt|j}|j}|dur?|dkr.|d7}n|dkr7|d7}n|dkr?|d7}||t<tdt dS) Nrz{}-{}rz-0r,z-1z-dr) rrr}rr`rarr4rjr%)rrI single_headerrrErErFrs   z_B3SingleHeader._injectc Cs tt|}|s dSd}d}d}|d}d}d}t|dkr"|\}nt|dkr-|\}}nt|dkr<|dd\}}}z6|durGt|pFd}|durQt|pPd}d}|durk|dkr^t}n |dkret}n|dkrkt}t|||dWSt t fyt d |YdSw) N-r,rrrdrz"received invalid b3 header, b3: %r) rM&_POSSIBLE_HTTP_HEADER_B3_SINGLE_HEADERsplitrSrrrrrrrr}r) rIrrrrpartsrrrrErErFr1sP        z_B3SingleHeader._extractrrErErErFrs & $rc@s&eZdZdZeddZededeeee dffddZ ed e edee ee eefe ee effd d Ze dd ede ede efddZede eefde efddZe ddedede e dde ede e eefdef ddZedede eefdd fddZd S) _TraceContexta Helper class to inject/extract W3C Trace Context https://www.w3.org/TR/trace-context/ Overview: - ``traceparent`` header describes the position of the incoming request in its trace graph in a portable, fixed-length format. Its design focuses on fast parsing. Every tracing tool MUST properly set traceparent even when it only relies on vendor-specific information in tracestate - ``tracestate`` header extends traceparent with vendor-specific data represented by a set of name/value pairs. Storing information in tracestate is optional. The format for ``traceparent`` is:: HEXDIGLC = DIGIT / "a" / "b" / "c" / "d" / "e" / "f" value = version "-" version-format version = 2HEXDIGLC version-format = trace-id "-" parent-id "-" trace-flags trace-id = 32HEXDIGLC parent-id = 16HEXDIGLC trace-flags = 2HEXDIGLC Example value of HTTP ``traceparent`` header:: value = 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01 base16(version) = 00 base16(trace-id) = 4bf92f3577b34da6a3ce929d0e0e4736 base16(parent-id) = 00f067aa0ba902b7 base16(trace-flags) = 01 // sampled The format for ``tracestate`` is key value pairs with each entry limited to 256 characters. An example of the ``dd`` list member we would add is:: "dd=s:2;o:rum;t.dm:-4;t.usr.id:baz64;t.ksr:0.0001" Implementation details: - Datadog Trace and Span IDs are 64-bit unsigned integers. - The W3C Trace Context Trace ID is a 16-byte hexadecimal string. - If the incoming traceparent is invalid we DO NOT use the tracecontext headers. Otherwise, the trace-id value is set to the hex-encoded value of the trace-id. If the trace-id is a 64-bit value (i.e. a Datadog trace-id), then the upper half of the hex-encoded value will be all zeroes. - The tracestate header will have one list member added to it, ``dd``, which contains values that would be in x-datadog-tags as well as those needed for propagation information. The keys to the ``dd`` values have been shortened as follows to save space: ``sampling_priority`` = ``s`` ``origin`` = ``o`` ``_dd.p.`` prefix = ``t.`` cCs |ddS)N~=)replace)tag_valrErErFdecode_tag_vals z_TraceContext.decode_tag_valtprA)rr,c Cst|}|durtd||\}}}}}|dkr$td||dkr/td|n|dkr=|dur=td|t|}t|}|dkrMtd |dkrUtd t|} | d @r_d nd} ||| fS) zIf there is no traceparent, or if the traceparent value is invalid raise a ValueError. Otherwise we extract the trace-id, span-id, and sampling priority from the traceparent header. NzInvalid traceparent version: %sffz(ff is an invalid traceparent version: %s00z=unsupported traceparent version:%r, still attempting to parsezRTraceparents with the version `00` should contain 4 values delimited by a dash: %srz0 value for trace_id is invalidz0 value for span_id is invalidr,)_TRACEPARENT_HEX_REGEXmatchstriprgroupsr}r~r[) rvalid_tp_valuesversion trace_id_hex span_id_hextrace_flags_hex future_valsrr trace_flagsrrErErF_get_traceparent_valuess2    z%_TraceContext._get_traceparent_valuests_lcCsd}|D]}|dr|dd}tdd|dD}q|rP|d}|dur.t|}nd}|d}|rsz7_TraceContext._get_tracestate_values..;sopcSs2i|]\}}|drd|ddt|qS)zt.z_dd.p.%srN)rQrrrsrErErFrws z8_TraceContext._get_tracestate_values..)rQrrgetrZrrrO)rddlist_memsampling_priority_tssampling_priority_ts_intrlpidother_propagated_tagsrErErF_get_tracestate_valuess(         z$_TraceContext._get_tracestate_valuesNtraceparent_sampledtracestate_sampling_priorityrcCsV| o|dk}|s|dkr|r|dkrd}|S|s'|dkr'|r#|dkr'd}|S|}|S)a When the traceparent sampled flag is set, the Datadog sampling priority is either 1 or a positive value of sampling priority if propagated in tracestate. When the traceparent sampled flag is not set, the Datadog sampling priority is either 0 or a negative value of sampling priority if propagated in tracestate. When origin is "rum" and there is no sampling priority propagated in tracestate, the above rules do not apply. rumrr,rE)rrrfrom_rum_wo_priorityrrErErF_get_sampling_prioritys&  z$_TraceContext._get_sampling_priorityrIc Csztt|}|durtdWdSt|\}}}Wnttfy1tjd|ddidYdSwt |i}tt |}t |||||S)Nzno traceparent headerz%received invalid w3c traceparent: %s send_to_telemetryF)extra) rM!_POSSIBLE_HTTP_HEADER_TRACEPARENTr}rrrrAssertionError exceptionr' _POSSIBLE_HTTP_HEADER_TRACESTATE _get_context)rIrrr trace_flagrtsrErErFrs   z_TraceContext._extractrrrrrc Cs|duri}d}|}|rndd|dD}d|}td|r(td|nF||t<zt|}Wnt t fyFtd|d}Ynw|rh|\} } }} | | | r\| |t <|durgt|| |}ntd|t|||||dS) NcSsg|]}|qSrEr)rtmemberrErErF 5sz._TraceContext._get_context..,z [^\x20-\x7E]+z&received invalid tracestate header: %rz3received invalid dd header value in tracestate: %r z9no dd list member in tracestate from incoming request: %rr)rjoinresearchr}rr(rrrrupdaterOr"rr) rrrrrrrrtracestate_valuesrrrrErErFr&sD     z_TraceContext._get_contextrcCsx|j}|r5||t<|jdurt|j|jpd|t<nt|jvr0t |jtd}t|j||t<n|j|t<t dt dS)NFrrYr) _traceparentr; _is_remoter+ _tracestaterr=r"rrZrjr)rrIrrrErErFrYs    z_TraceContext._injectrB)rrrrrrrtuplerZrrrrrrrrrrrrErErErFrjsH/ ",8% "   2$rc@seZdZdZdZdZededefddZededefd d Z ed e d e eefdd fddZ ede fddZ ed e eefde fddZd S)_BaggageHeaderz.Helper class to inject/extract Baggage HeaderszMABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'*+-.^_`|~zYABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'()*+-./:<>?@[]^_`{|}~rTrAcCtjjt|tjdSN)safe)urllibparsequoterrr SAFE_CHARACTERS_KEYrlrErErF _encode_keytz_BaggageHeader._encode_keyrUcCr r )rrrrrr SAFE_CHARACTERS_VALUE)rUrErErF _encode_valuexrz_BaggageHeader._encode_valuerrINc Cs|j}|s dSzqt|tkr%tdtjtj ddddt |t}g}d}|D]>\}}t |dt |}t|d|rFdnd}||tkr`td tjtj ddd dn ||||7}q+d |} | |t<td tWdStytd YdSw)Nz2Baggage item limit exceeded, dropping excess itemszcontext_header.truncatedr,))truncation_reasonbaggage_item_count_exceededrdrrzutf-8z3Baggage header size exceeded, dropping excess items))rbaggage_byte_count_exceededrrz*Failed to encode and inject baggage header)_baggagerOrSr r}r~r rhrri itertoolsislicer rrencoderappendrr?rjr Exception) rrI baggage_items encoded_items total_sizerTrUr item_size header_valuerErErFr|sF           z_BaggageHeader._injectcCs$tjtjdddtffdtidS)zGRecord telemetry for malformed baggage header and return empty context.zcontext_header_style.malformedr,rcrdr>)r rhrrirrrErErErF"_record_malformed_and_return_emptys z1_BaggageHeader._record_malformed_and_return_emptycCstt|}|s tidSi}|d}|D]2}d|vr!tS|dd\}}tj| }tj| }|r=|sCtS|||<qt|dS)Nr$rrr,) rM_POSSIBLE_HTTP_BAGGAGE_HEADERrrr r%rrunquoter)rIr#r>baggages key_valuerTrUrErErFrs       z_BaggageHeader._extract)rrrrrrrrrrrrrr%rrErErErFr ns , r c @seZdZdZe ddeeefdeedefddZ ede e e fde e ee e ffd d Zed ed e d e deefddZeddZed eeefde e e fddfddZeddZdS)HTTPPropagatorzA HTTP Propagator using HTTP headers as carrier. Injects and Extracts headers according to the propagation style set by ddtrace configurations. N trace_infonon_active_spanrAcCst|tr|jn|}|jdur|Stjdurtd||Sd}|dur(|j}nt|tr1|j}ntj }r@|j |j kr@|}|rOtj |t d|||S)zHandle sampling decision and return context for header injection. If sampling_priority is already set, returns immediately. Otherwise, finds the appropriate span and triggers sampling before returning the injection context. NzTNo tracer found and injection context %s has no sampling priority, skipping samplingz4%s sampled before propagating trace: span_context=%s) isinstancerrNrr tracerr}error _local_rootcurrent_root_spanrsampler)r+r,injection_context sampling_span current_rootrErErF_get_sampled_injection_contexts(    z-HTTPPropagator._get_sampled_injection_contextnormalized_headerscCsdg}g}tjdur.tjD]!}|tkrq t|}||}|r-td|||||q ||fS)Ncontext_header_style.extracted)r _propagation_style_extractr _PROP_STYLESrrjr)r7contexts styles_w_ctx prop_style propagatorrNrErErF"_extract_configured_contexts_avails      z1HTTPPropagator._extract_configured_contexts_availrNstylereasoncCsV|jr)|jr)t|j|j|jr|jdkrdnd|tkr!|jtdnd||ddSdS)Nrr,rn)rAcontext_headers)rr< attributes)rrrrrrrr()rNr@rArErErF_context_to_span_links  z$HTTPPropagator._context_to_span_linkc Cs|d}g}t|dddD]f\}}||}|jr/|j|jkr/t||d}|r.||q|tkrutt|} | r?| |jt <|j|jkru|j |j krud} t |vrX|| t } t |jvrf|jt |jt <n | rqd| j |jt <|j |_ q||_|S)Nrr,terminated_contextr^) enumeraterr*rDrrrMrrr(rr&indexr"r` _span_links) r;r<r7primary_contextlinksirN style_w_ctxlinkr dd_contextrErErF_resolve_contexts$s:    z HTTPPropagator._resolve_contextsrIcCst|d}|jr|jr|jdurtd||td||ft j s%dSt t j vr0t |||jdus:|jdurBtd|dSt jdur[|jdur[|jD] }|j||t|<qOtt j vrft ||tt j vrqt ||tt j vr|t ||tt j vrt ||dSdS)a(Inject Context attributes that have to be propagated as HTTP headers. Here is an example using `requests`:: import requests from ddtrace.propagation.http import HTTPPropagator def parent_call(): with tracer.start_span('parent_span') as span: headers = {} # Preferred: Pass span object to context argument HTTPPropagator.inject(span, headers) url = '' r = requests.get(url, headers=headers) with tracer.start_span('child_span2') as span: headers = {} # Alternative: Pass context, but ensure sampling_priority is set tracer.sample(span) HTTPPropagator.inject(span.context, headers) url = '' r = requests.get(url, headers=headers) :param Union[Span, Context] context: Pass a Span object (preferred) or Context object. Span objects automatically trigger sampling decisions. Context objects should have sampling_priority set to avoid inconsistent downstream sampling. :param dict headers: HTTP headers to extend with tracing attributes. NzSampling decision not available. Downstream spans will not inherit a sampling priority: args=(context=%s, ...) detected span context=%szhttp.span_injectrT)r*r6rrrr}rr dispatchr _propagation_style_injectrr r!_propagation_http_baggage_enabledrr.r&rkr$rr%rrr)rNrIrrTrErErFinjectKs6 !           zHTTPPropagator.injectcCst}|rtjs |Szd}dd|D}tjr.r8TrcSsg|] }|r|qSrEr)rtrurErErFrsz*HTTPPropagator.extract..*Npropagation_behavior_extract)r> span_linksz2error while extracting context propagation headersrz)rr r9rO_propagation_extract_firstr:rrjrRrWr*r?rOrr rget_all_baggage_items_baggage_tag_keyskeysget_baggage_itemrr_propagation_behavior_extractrrDrr}r)rIrNr@r7r=r>r;r<baggage_contextraw_keystag_keys stripped_keyrU prefixed_keyrMrErErFextractsd                 zHTTPPropagator.extractrB)rrrrrrrrrr6rrr rr?rrDrOrSrbrErErErFr*s*  (,  &(Dr*rB)xrrtypingrrr urllib.parserddtrace._trace._span_linkrddtrace._trace.contextrddtrace._trace.spanrrr ddtrace.appsec._constantsr ddtrace.internalr !ddtrace.internal.settings._configr ddtrace.internal.settings.asmrddtrace.internal.telemetryr $ddtrace.internal.telemetry.constantsr constantsrrrinternal._tagsetrrrrrrinternal.compatrinternal.constantsrrrrrr r!rr"r#r_r$r%r&r'r(internal.loggerr)internal.samplingr*internal.utils.httpr+_utilsr-rr}r.__annotations__r/r0r1r2r4r5r6r7r8r9r;r=r?rrCrGrrrrrDrprrrrrrrrPr&compileVERBOSErrrMrWrZr[rrarjrkrrrr r:objectr*rErErErFs                                                cut]