sdkagent

dd-trace-py API reference

400 public APIs from dd-trace-py (DataDog/dd-trace-py) — 122 classes, 179 functions, 99 methods. Signatures extracted by static analysis of the actual source.

Repository: DataDog/dd-trace-py

KindCount
Classes122
Functions179
Methods99

API list

func.gitlab.validate-ddtrace-package.identify_version_mismatches(actual_set:set[tuple[str, str, str, str]], package_version:str) -> dict[str, tuple[str, str]]
Identify wheels with wrong versions.
func.gitlab.validate-ddtrace-package.parse_actual_wheels(wheels_dir:str) -> tuple[set[tuple[str, str, str, str]], list[str], int]
Parse actual wheel files.
func.gitlab.validate-ddtrace-package.reconstruct_wheel_filename(version:str, python_tag:str, platform:str, flavor:str) -> str
Reconstruct wheel filename from components.
func.gitlab.validate-ddtrace-package.validate_sdist(wheels_dir:str, package_version:str) -> tuple[bool, str, str | None]
Validate sdist exists and has correct version.
funcddtrace._logger.configure_ddtrace_logger() -> None
Configures ddtrace log levels and file paths.
classddtrace._monkey.PatchException
Wraps regular `Exception` class when patching modules
funcddtrace._monkey.patch(raise_errors:bool=True, **patch_modules:Union[list[str], bool]) -> None
Patch only a set of given modules.
funcddtrace._monkey.patch_all(**patch_modules:bool) -> None
Enables ddtrace library instrumentation.
classddtrace._trace._span_link.SpanLinkKind
A collection of standard SpanLink kinds.
methodddtrace._trace.context.Context.copy(trace_id:int, span_id:int) -> 'Context'
Return a shallow copy of the context with the given correlation IDs.
methodddtrace._trace.context.Context.dd_origin() -> Optional[Text]
Get the origin of the trace.
methodddtrace._trace.context.Context.dd_user_id() -> Optional[Text]
Get the user ID of the trace.
methodddtrace._trace.context.Context.get_all_baggage_items() -> dict[str, Any]
Returns all baggage items in this span context.
methodddtrace._trace.context.Context.get_baggage_item(key:str) -> Optional[Any]
Gets a baggage item in this span context.
methodddtrace._trace.context.Context.remove_all_baggage_items() -> None
Removes all baggage items from this span context.
methodddtrace._trace.context.Context.remove_baggage_item(key:str) -> None
Remove a baggage item from this span context.
methodddtrace._trace.context.Context.set_baggage_item(key:str, value:Any) -> None
Sets a baggage item in this span context.
classddtrace._trace.events.TracingEvent
TracingEvent is a specialization of Event.
classddtrace._trace.processor.TraceSamplingProcessor
Processor that runs both trace and span sampling rules.
classddtrace._trace.processor.TraceTagsProcessor
Processor that applies trace-level tags to the trace.
methodddtrace._trace.span.Span.context() -> Context
The trace context for this span.
methodddtrace._trace.span.Span.finish(finish_time:Optional[float]=None) -> None
Mark the end time of the span and submit it to the tracer.
methodddtrace._trace.span.Span.get_metrics() -> dict[str, NumericType]
Return all metrics.
methodddtrace._trace.span.Span.get_tags() -> dict[str, str]
Return all string tags.
methodddtrace._trace.span.Span.link_span(context:Context, attributes:Optional[Mapping[str, Any]]=None) -> None
Defines a causal relationship between two spans
methodddtrace._trace.span.Span.record_exception(exception:BaseException, attributes:Optional[dict[str, _AttributeValueType]]=None) -> None
Records an exception as a span event.
methodddtrace._trace.span.Span.remove_metric(key:str) -> None
Remove a metric from the span.
methodddtrace._trace.span.Span.remove_tag(key:str) -> None
Remove a tag from the span.
methodddtrace._trace.span.Span.set_metric(key:str, value:NumericType) -> None
This method sets a numeric tag value for the given key.
methodddtrace._trace.span.Span.set_metrics(metrics:dict[str, NumericType]) -> None
Set a dictionary of metrics on the given span.
methodddtrace._trace.span.Span.set_tag(key:str, value:Optional[str]=None) -> None
Set a tag key/value pair on the span.
methodddtrace._trace.span.Span.set_tags(tags:dict[str, str]) -> None
Set a dictionary of tags on the given span.
classddtrace._trace.subscribers.llm.LlmTracingSubscriber
Shared tracing logic for all LLM integrations.
methodddtrace._trace.subscribers.llm.LlmTracingSubscriber.on_ended(ctx:core.ExecutionContext['LlmRequestEvent'], exc_info:tuple[Optional[type], Optional[BaseException], Optional[TracebackType]]) -> None
Set LLMObs tags on the span.
classddtrace._trace.subscribers.ray.RayCoreAPITracingSubscriber
Subscriber for core API calls (ray.get/wait/put).
classddtrace._trace.subscribers.ray.RayExecutionSubscriber
Subscriber for ray.execute context
classddtrace._trace.subscribers.ray.RayJobStartSubscriber
Subscriber for ray.job context
methodddtrace._trace.tracer.Tracer.agent_trace_url() -> Optional[str]
Trace agent url
methodddtrace._trace.tracer.Tracer.current_span() -> Optional[Span]
Return the active span in the current execution context.
methodddtrace._trace.tracer.Tracer.current_trace_context(*args, **kwargs) -> Optional[Context]
Return the context for the current trace.
methodddtrace._trace.tracer.Tracer.flush()
Flush the buffer of the trace writer.
methodddtrace._trace.tracer.Tracer.set_tags(tags:dict[str, str]) -> None
Set some tags at the tracer level.
methodddtrace._trace.tracer.Tracer.shutdown(timeout:Optional[float]=None) -> None
Shutdown the tracer and flush finished traces.
classddtrace.aiguard._api_client.AIGuardClientError
Exception for AI Guard client errors.
classddtrace.aiguard._api_client.Options
Optional evaluation behavior.
funcddtrace.aiguard._initialization.load_ai_guard() -> None
Lazily load the ai_guard module listeners.
classddtrace.aiguard.integrations.strands.AIGuardStrandsIntegration
Shared AI Guard evaluation logic for Strands Agents.
classddtrace.aiguard.integrations.strands.AIGuardStrandsPlugin
AI Guard security plugin for Strands Agents.
funcddtrace.aiguard.messages.try_format_json(value:Any) -> str
Format a value as a JSON string, falling back to str() on failure.
funcddtrace.appsec._asm_request_context.get_or_create_rasp_subcontext(ddwaf:Any, ctx:Any, rule_type:Optional[str]) -> Optional[Any]
Return the subcontext to use for a RASP WAF call.
funcddtrace.appsec._asm_request_context.should_analyze_body_response(env:ASM_Environment) -> bool
Check if we should analyze body for API10.
funcddtrace.appsec._common_module_patches.popen_FD233052260D8B4D(arg_list:Union[list[str], str, bytes]) -> None
listener for subprocess.Popen class
funcddtrace.appsec._common_module_patches.wrapped_system_5542593D237084A7(command:Union[str, bytes]) -> None
wrapper for os.system function
classddtrace.appsec._constants.API_SECURITY
constants related to API Security
classddtrace.appsec._constants.APPSEC
Specific constants for AppSec
classddtrace.appsec._constants.IAST
Specific constants for IAST
classddtrace.appsec._constants.IAST_SPAN_TAGS
Specific constants for IAST span tags
classddtrace.appsec._constants.LOGIN_EVENTS_MODE
string identifier for the mode of the user login events.
classddtrace.appsec._constants.PRODUCTS
string identifier for remote config products
classddtrace.appsec._constants.SCA
SCA (Software Composition Analysis) related constants.
classddtrace.appsec._constants.WAF_ACTIONS
string identifier for actions returned by the waf
classddtrace.appsec._ddwaf.ddwaf_types.ddwaf_object_kv
A key/value pair stored in a ddwaf_object map.
funcddtrace.appsec._http_utils.extract_cookies_from_headers(normalized_headers:MutableMapping[str, str]) -> Optional[dict[str, str]]
Extract cookies from the WAF headers.
funcddtrace.appsec._http_utils.normalize_headers(request_headers:Mapping[str, str]) -> dict[str, str]
Normalize headers according to the WAF expectations.
classddtrace.appsec._iast._patch_modules.IASTFunction
Represents a function to be patched for IAST analysis.
classddtrace.appsec._iast._patch_modules.WrapFunctonsForIAST
Manages the collection and patching of IAST modules.
funcddtrace.appsec._iast._taint_tracking.aspects.template_string_aspect(*args:list[Any]) -> Any
Aspect for PEP-750 template strings (t-strings).
funcddtrace.appsec._iast.load_iast()
Lazily load the iast module listeners.
classddtrace.appsec._iast.reporter.IastSpanReporter
Class representing an IAST span reporter.
methodddtrace.appsec._iast.reporter.IastSpanReporter.get_unredacted_value_parts(evidence_value:str, ranges:list[dict], sources:list[Any]) -> list[dict]
Gets unredacted value parts of evidence.
methodddtrace.appsec._iast.reporter.IastSpanReporter.taint_ranges_as_evidence_info(pyobject:Any) -> tuple[list[Source], list[dict]]
Extracts tainted ranges as evidence information.
funcddtrace.appsec._iast.secure_marks.configuration.parse_parameters(positions_string:str) -> list[int]
Parse comma-separated parameter positions.
funcddtrace.appsec._iast.secure_marks.validators.cmdi_validator(wrapped:Callable, instance:Any, args:Sequence, kwargs:dict) -> bool
Validator for command quoting functions.
funcddtrace.appsec._iast.secure_marks.validators.path_traversal_validator(wrapped:Callable, instance:Any, args:Sequence, kwargs:dict) -> bool
Validator for secure filename functions.
funcddtrace.appsec._iast.secure_marks.validators.sqli_validator(wrapped:Callable, instance:Any, args:Sequence, kwargs:dict) -> bool
Validator for SQL quoting functions.
funcddtrace.appsec._iast.secure_marks.validators.ssrf_validator(wrapped:Callable, instance:Any, args:Sequence, kwargs:dict) -> bool
Validator for ssrf functions.
funcddtrace.appsec._iast.secure_marks.validators.unvalidated_redirect_validator(wrapped:Callable, instance:Any, args:Sequence, kwargs:dict) -> bool
Validator for unvalidated redirect functions.
funcddtrace.appsec._iast.taint_sinks.weak_cipher.patch()
Wrap hashing functions.
funcddtrace.appsec._iast.taint_sinks.weak_hash.patch()
Wrap hashing functions.
funcddtrace.appsec._listeners.load_appsec(reconfigure_tracer:bool=False, origin:str='') -> bool
Lazily load the appsec module listeners.
funcddtrace.appsec._listeners.load_common_appsec_modules() -> None
Lazily load the common module patches.
funcddtrace.appsec._metrics.report_error(msg:str, version:str, action:str, error_level:bool=True) -> None
used for waf configuration errors
funcddtrace.appsec._metrics.report_waf_run_error(error:int, rule_version:str, rule_type:Optional[str]) -> None
used for waf run errors
classddtrace.appsec._remoteconfiguration.AppSecCallback
Remote config callback for AppSec products.
funcddtrace.appsec._trace_utils.should_block_user(tracer:Any, userid:str, session_id:Optional[str]=None) -> bool
Return true if the specified User ID should be blocked.
funcddtrace.appsec._trace_utils.track_custom_event(tracer:Any, event_name:str, metadata:dict[str, Any]) -> None
Add a new custom tracking event.
classddtrace.appsec.sca._instrumenter.Instrumenter
Manages bytecode instrumentation of target functions.
methodddtrace.appsec.sca._instrumenter.Instrumenter.instrument(qualified_name:str, func:FunctionType) -> bool
Instrument a function with SCA detection hook.
funcddtrace.appsec.sca._instrumenter.get_instrumenter(registry:InstrumentationRegistry) -> Instrumenter
Get or create the singleton Instrumenter instance.
funcddtrace.appsec.sca._instrumenter.sca_detection_hook(qualified_name:str) -> None
Hook injected into instrumented functions.
funcddtrace.appsec.sca._instrumenter.set_registry(registry:InstrumentationRegistry) -> None
Set global registry reference.
classddtrace.appsec.sca._registry.InstrumentationRegistry
Thread-safe registry of instrumentation state.
methodddtrace.appsec.sca._registry.InstrumentationRegistry.merge_cve_ids(qualified_name:str, new_cve_ids:list[str]) -> bool
Merge additional CVE IDs into an existing target.
classddtrace.appsec.sca._registry.InstrumentationState
State for a single instrumented target.
classddtrace.appsec.sca._registry.TargetInfo
Immutable snapshot of vulnerability info for a target.
funcddtrace.appsec.sca._registry.get_global_registry() -> InstrumentationRegistry
Get or create global registry instance.
classddtrace.appsec.sca._resolver.SymbolResolver
Resolve qualified names to Python callables.
methodddtrace.appsec.sca._resolver.SymbolResolver.resolve(qualified_name:str) -> Optional[tuple[str, FunctionType]]
Resolve a qualified name to a callable.
funcddtrace.appsec.track_user_sdk.track_custom_event(event_name:str, metadata:dict[str, t.Any]) -> None
Track a custom user event.
funcddtrace.appsec.track_user_sdk.track_login_failure(login:str, exists:bool, user_id:t.Any=None, metadata:t.Optional[dict[str, t.Any]]=None, _auto:bool=False) -> None
Track a failed user login event.
funcddtrace.appsec.track_user_sdk.track_login_success(login:str, user_id:t.Any=None, metadata:t.Optional[dict[str, t.Any]]=None, _auto:bool=False) -> None
Track a successful user login event.
funcddtrace.appsec.track_user_sdk.track_signup(login:str, user_id:t.Any=None, success:bool=True, metadata:t.Optional[dict[str, t.Any]]=None, _auto:bool=False) -> None
Track a user signup event.
funcddtrace.appsec.track_user_sdk.track_user(login:str, user_id:t.Any=None, session_id:t.Optional[str]=None, metadata:t.Optional[dict[str, t.Any]]=None, _auto:bool=False) -> None
Track an authenticated user.
classddtrace.contrib._events.http.HttpBaseEvent
Common HTTP request/response data.
classddtrace.contrib._events.http.HttpRequestBaseEvent
Base event for traced HTTP requests.
classddtrace.contrib._events.http_client.HttpClientRequestEvent
HTTP client request event
classddtrace.contrib._events.llm.LlmRequestEvent
LLM request event for all LLM integrations.
classddtrace.contrib.dbapi.TracedConnection
TracedConnection wraps a Connection with tracing code.
classddtrace.contrib.dbapi.TracedCursor
TracedCursor wraps a psql cursor and traces its queries.
methodddtrace.contrib.dbapi.TracedCursor.callproc(proc, *args)
Wraps the cursor.callproc method
methodddtrace.contrib.dbapi.TracedCursor.execute(query, *args, **kwargs)
Wraps the cursor.execute method
classddtrace.contrib.dbapi_async.FetchTracedAsyncCursor
FetchTracedAsyncCursor for psycopg
funcddtrace.contrib.internal.aredis.patch.patch()
Patch the instrumented methods
funcddtrace.contrib.internal.avro.patch.patch()
Patch the instrumented methods
funcddtrace.contrib.internal.botocore.services.bedrock.handle_bedrock_request(ctx:core.ExecutionContext) -> None
Perform request param extraction and tagging.
funcddtrace.contrib.internal.bottle.patch.patch()
Patch the bottle.Bottle class
funcddtrace.contrib.internal.celery.utils.set_tags_from_context(span:Span, context:dict[str, Any]) -> None
Helper to extract meta values from a Celery Context
funcddtrace.contrib.internal.coverage.patch.coverage_report_wrapper(func:Any, instance:Any, args:tuple, kwargs:dict) -> Any
Wrapper to cache percentage when report() is called.
funcddtrace.contrib.internal.coverage.patch.erase_coverage() -> None
Erase all coverage data and clear the cache.
funcddtrace.contrib.internal.coverage.patch.get_coverage_instance() -> Optional[Any]
Get the current Coverage instance.
funcddtrace.contrib.internal.coverage.patch.reset_coverage_state() -> None
Reset all coverage state.
funcddtrace.contrib.internal.coverage.patch.set_coverage_instance(cov_instance:Any) -> None
Set the current coverage instance.
funcddtrace.contrib.internal.coverage.patch.start_coverage(source:Any=None, omit:Any=None, include:Any=None, config_file:Any=True, auto_data:bool=False, data_suffix:Optional[str]=None, **kwargs:Any) -> Optional[Any]
Start coverage collection.
funcddtrace.contrib.internal.coverage.patch.stop_coverage(save:bool=True, erase:bool=False) -> Optional[Any]
Stop coverage collection.
funcddtrace.contrib.internal.coverage.patch.unpatch()
Remove Coverage.py patching.
funcddtrace.contrib.internal.django.cache.func_cache_operation(func:FunctionType) -> str
Returns the cache operation name for the given function.
funcddtrace.contrib.internal.django.middleware.wrap_middleware(mw:Any, mw_path:str) -> None
Wraps a Django middleware class or function.
funcddtrace.contrib.internal.django.patch.instrument_view(django, view)
Helper to wrap Django views.
funcddtrace.contrib.internal.django.restframework.patch_restframework(django)
Patches rest_framework app.
funcddtrace.contrib.internal.django.utils.quantize_key_values(keys:_quantize_param) -> Text
Used for Django cache key normalization.
funcddtrace.contrib.internal.django.utils.resource_from_cache_prefix(resource:str, cache:Any) -> str
Combine the resource name with the cache prefix (if any)
funcddtrace.contrib.internal.flask.patch.patch()
Patch `flask` module for tracing
funcddtrace.contrib.internal.gevent.patch.unpatch()
Restore the original ``Greenlet``.
funcddtrace.contrib.internal.google_adk.patch.unpatch()
Unpatch the `google.adk` library.
funcddtrace.contrib.internal.kombu.utils.get_routing_key_from_args(args)
Extract the routing key
funcddtrace.contrib.internal.llama_index._utils.build_agent_run_request_kwargs(args:tuple[Any, ...], kwargs:dict[str, Any]) -> dict[str, Any]
Build trace kwargs for agent ``run()``.
funcddtrace.contrib.internal.llama_index._utils.get_model_provider(instance:Any) -> str
Extract the LLM provider name from a LlamaIndex instance.
funcddtrace.contrib.internal.openai_agents.patch.patch()
Patch the instrumented methods
funcddtrace.contrib.internal.protobuf.patch.patch()
Patch the instrumented methods
classddtrace.contrib.internal.psycopg.async_cursor.Psycopg3FetchTracedAsyncCursor
Psycopg3FetchTracedAsyncCursor for psycopg
classddtrace.contrib.internal.psycopg.cursor.Psycopg2FetchTracedCursor
FetchTracedCursor for psycopg2
classddtrace.contrib.internal.psycopg.cursor.Psycopg2TracedCursor
TracedCursor for psycopg2
classddtrace.contrib.internal.psycopg.cursor.Psycopg3FetchTracedCursor
Psycopg3FetchTracedCursor for psycopg
classddtrace.contrib.internal.psycopg.cursor.Psycopg3TracedCursor
TracedCursor for psycopg instances
funcddtrace.contrib.internal.pymemcache.patch.unpatch()
Remove pymemcache tracing
funcddtrace.contrib.internal.pymongo.client.parse_socket_command_spec(args, kwargs)
Parse socket command spec.
funcddtrace.contrib.internal.pymongo.utils.is_query(op)
Check if operation is a query.
funcddtrace.contrib.internal.pymongo.utils.normalize_filter(f=None)
Normalize filter queries.
funcddtrace.contrib.internal.pymongo.utils.set_address_tags(span, address)
Set address tags on span.
funcddtrace.contrib.internal.pyramid.patch.patch()
Patch pyramid.config.Configurator
funcddtrace.contrib.internal.pytest._plugin_v2.pytest_runtest_makereport(item:pytest.Item, call:pytest_CallInfo) -> None
Store outcome for tracing.
funcddtrace.contrib.internal.pytest.plugin.pytest_addoption(parser)
Add ddtrace options.
funcddtrace.contrib.internal.pytorch._c_tracer.clear_parent_context() -> None
Clear the process-wide parent context.
funcddtrace.contrib.internal.pytorch._device.discover(local_rank:int) -> DeviceInfo
Resolve and cache the device id.
funcddtrace.contrib.internal.pytorch._rank_root.close() -> None
Finish the per-rank span.
funcddtrace.contrib.internal.pytorch._rank_root.open_rank_span(rank:int, world_size:int, framework:str, training_job_id:Optional[str]) -> None
Open the per-rank lifetime span.
funcddtrace.contrib.internal.pytorch._utils.restore_run_metadata_snapshot(snapshot:dict[str, Any]) -> None
Replace the cache with a previously taken snapshot.
funcddtrace.contrib.internal.pytorch._utils.set_cached_run_metadata(*run_name:Optional[str]=None, *submission_id:Optional[str]=None, *metadata:Optional[dict[str, Any]]=None) -> None
Update the run-metadata cache.
funcddtrace.contrib.internal.ray.core.api.traced_get(wrapped, instance, args, kwargs)
Trace the calls of ray.get
funcddtrace.contrib.internal.ray.core.api.traced_put(wrapped, instance, args, kwargs)
Trace the calls of ray.put
funcddtrace.contrib.internal.ray.core.api.traced_wait(wrapped, instance, args, kwargs)
Trace the calls of ray.wait
funcddtrace.contrib.internal.ray.core.utils.extract_signature(func:Any, ignore_first:bool=False) -> list[Parameter]
Extract the function signature from the function.
funcddtrace.contrib.internal.ray.core.utils.get_dd_job_name_from_entrypoint(entrypoint:str)
Get the job name from the entrypoint.
funcddtrace.contrib.internal.ray.core.utils.get_signature(func:Any) -> inspect.Signature
Get signature parameters.
funcddtrace.contrib.internal.ray.core.utils.redact_paths(s:str) -> str
Redact path-like substrings from an entry-point string.
funcddtrace.contrib.internal.ray.patch.traced_submit_job(wrapped, instance, args, kwargs)
Trace job submission.
funcddtrace.contrib.internal.rediscluster.patch.patch()
Patch the instrumented methods
funcddtrace.contrib.internal.requests.patch.patch()
Activate http calls tracing
funcddtrace.contrib.internal.requests.patch.unpatch()
Disable traced sessions
funcddtrace.contrib.internal.rq.patch.traced_job_perform(rq, pin, func, instance, args, kwargs)
Trace rq.Job.perform(...)
funcddtrace.contrib.internal.sanic.patch.patch()
Patch the instrumented methods.
funcddtrace.contrib.internal.sanic.patch.unpatch()
Unpatch the instrumented methods.
classddtrace.contrib.internal.subprocess.patch.SubprocessCmdLine
Parser and scrubber for subprocess command lines.
methodddtrace.contrib.internal.subprocess.patch.SubprocessCmdLine.truncate_string(str_:str) -> str
Truncate a string if it exceeds the size limit.
funcddtrace.contrib.internal.subprocess.patch.del_lst_callback(name:str)
Remove a list command callback.
funcddtrace.contrib.internal.subprocess.patch.del_str_callback(name:str)
Remove a string command callback.
funcddtrace.contrib.internal.vllm.extractors.parse_prompt_to_messages(prompt:Optional[str]) -> list[Message]
Parse a formatted prompt into structured messages.
funcddtrace.contrib.internal.vllm.utils.set_latency_metrics(span:Span, latency_metrics:Optional[LatencyMetrics]) -> None
Set latency span tags from pre-computed metrics.
funcddtrace.contrib.internal.yaaredis.patch.patch()
Patch the instrumented methods
methodddtrace.debugging._debugger.Debugger.disable(join:bool=True) -> None
Disable dynamic instrumentation.
classddtrace.debugging._debugger.DebuggerError
Generic debugger error.
methodddtrace.debugging._encoding.Encoder.encode(item:Any) -> bytes
Encode the given snapshot.
funcddtrace.debugging._exception.replay.exception_ident(exc:BaseException, tb:t.Optional[TracebackType]) -> int
Compute the identity of an exception.
funcddtrace.debugging._exception.replay.get_tb_frames_from_exception_chain(chain:ExceptionChain) -> t.Generator[tuple[int, TracebackType], None, None]
Get the frames from the exception chain.
classddtrace.debugging._function.discovery.FullyNamed
A fully named object.
classddtrace.debugging._function.discovery.FullyNamedFunction
A fully named function object.
classddtrace.debugging._function.discovery.FunctionDiscovery
Discover all function objects in a module.
methodddtrace.debugging._function.discovery.FunctionDiscovery.at_line(line:int) -> list[FullyNamedFunction]
Get the functions at the given line.
methodddtrace.debugging._function.discovery.FunctionDiscovery.by_name(qualname:str) -> FullyNamedFunction
Get the function by its qualified name.
classddtrace.debugging._function.store.FullyNamedContextWrappedFunction
A fully named wrapper function.
classddtrace.debugging._function.store.FunctionStore
Function object store.
methodddtrace.debugging._function.store.FunctionStore.eject_hook(function:FunctionType, hook:HookType, line:int, arg:Any) -> bool
Eject a hook from a function.
methodddtrace.debugging._function.store.FunctionStore.eject_hooks(function:FunctionType, hooks:list[HookInfoType]) -> set[str]
Bulk-eject hooks from a function.
methodddtrace.debugging._function.store.FunctionStore.inject_hook(function:FullyNamedContextWrappedFunction, hook:HookType, line:int, arg:Any) -> bool
Inject a hook into a function.
methodddtrace.debugging._function.store.FunctionStore.inject_hooks(function:FullyNamedContextWrappedFunction, hooks:list[HookInfoType]) -> set[str]
Bulk-inject hooks into a function.
methodddtrace.debugging._function.store.FunctionStore.unwrap(function:FullyNamedContextWrappedFunction) -> None
Unwrap a hook around a wrapped function.
methodddtrace.debugging._function.store.FunctionStore.wrap(function:FunctionType, wrapping_context:WrappingContext) -> None
Wrap a function with a hook.
classddtrace.debugging._origin.span.EntrySpanWrappingContext
Entry span wrapping context.
methodddtrace.debugging._probe.model.Probe.update(other:'Probe') -> None
Update the mutable fields from another probe.
classddtrace.debugging._probe.model.ProbeConditionMixin
Conditional probe.
classddtrace.debugging._probe.registry.ProbeRegistry
Keep track of all the registered probes.
methodddtrace.debugging._probe.registry.ProbeRegistry.get_pending(location:str) -> list[Probe]
Get the currently pending probes by location.
methodddtrace.debugging._probe.registry.ProbeRegistry.log_probe_status(probe:Probe) -> None
Log the status of a probe using the status logger.
methodddtrace.debugging._probe.registry.ProbeRegistry.register(*probes:Probe) -> None
Register a probe.
methodddtrace.debugging._probe.registry.ProbeRegistry.set_emitting(probe:Probe) -> None
Set the emitting flag for a probe.
methodddtrace.debugging._probe.registry.ProbeRegistry.set_error(probe:Probe, error_type:str, message:str) -> None
Set the error message for a probe.
methodddtrace.debugging._probe.registry.ProbeRegistry.set_installed(probe:Probe) -> None
Set the installed flag for a probe.
methodddtrace.debugging._probe.registry.ProbeRegistry.unregister(*probes:Probe) -> list[Probe]
Unregister a collection of probes.
funcddtrace.debugging._probe.remoteconfig.build_probe(attribs:dict[str, Any]) -> Probe
Create a new Probe instance.
funcddtrace.debugging._safety.get_globals(frame:FrameType) -> Iterator[tuple[str, Any]]
Get global variables referenced by the frame's code object.
classddtrace.debugging._signal.collector.SignalCollector
Debugger signal collector.
classddtrace.debugging._signal.log.LogSignal
A signal that also emits a log message.
methodddtrace.debugging._signal.log.LogSignal.has_message() -> bool
Whether the signal has a log message to emit.
methodddtrace.debugging._signal.log.LogSignal.message() -> t.Optional[str]
The log message to emit.
classddtrace.debugging._signal.metric_sample.MetricSample
Wrapper for making a metric sample
classddtrace.debugging._signal.model.Signal
Debugger signal base class.
classddtrace.debugging._signal.snapshot.Snapshot
Raw snapshot.
classddtrace.debugging._signal.tracing.DynamicSpan
Dynamically created span
classddtrace.debugging._signal.tracing.SpanDecoration
Decorate a span.
classddtrace.debugging._signal.trigger.Trigger
Trigger a session creation.
funcddtrace.debugging._signal.utils.serialize(value:Any, level:int=MAXLEVEL, maxsize:int=MAXSIZE, maxlen:int=MAXLEN, maxfields:int=MAXFIELDS) -> str
Python object serializer.
classddtrace.debugging._uploader.SignalUploader
Signal uploader.
methodddtrace.debugging._uploader.SignalUploader.reset() -> None
Reset the buffer on fork.
methodddtrace.debugging._uploader.SignalUploader.upload() -> None
Upload request.
classddtrace.debugging._uploader.SignalUploaderError
Signal uploader error.
classddtrace.debugging._uploader.UploaderProduct
Uploader products.
funcddtrace.ext.aws.get_aws_partition(region_name:str) -> str
Determine AWS partition from region name.
funcddtrace.ext.aws.truncate_arg_value(value:Any, max_len:int=1024) -> Any
Truncate values which are bytes and greater than `max_len`.
funcddtrace.ext.ci.extract_appveyor(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Appveyor environ.
funcddtrace.ext.ci.extract_azure_pipelines(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Azure pipelines environ.
funcddtrace.ext.ci.extract_bitbucket(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Bitbucket environ.
funcddtrace.ext.ci.extract_bitrise(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Bitrise environ.
funcddtrace.ext.ci.extract_buddy(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Buddy environ.
funcddtrace.ext.ci.extract_buildkite(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Buildkite environ.
funcddtrace.ext.ci.extract_circle_ci(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from CircleCI environ.
funcddtrace.ext.ci.extract_codebuild(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from codebuild environments.
funcddtrace.ext.ci.extract_codefresh(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Codefresh environ.
funcddtrace.ext.ci.extract_drone(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Drone environ.
funcddtrace.ext.ci.extract_github_actions(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Github Actions environment.
funcddtrace.ext.ci.extract_gitlab(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Gitlab environ.
funcddtrace.ext.ci.extract_jenkins(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Jenkins environ.
funcddtrace.ext.ci.extract_teamcity(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Teamcity environ.
funcddtrace.ext.ci.extract_travis(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Travis environ.
funcddtrace.ext.ci.github_actions.extract_github_actions(environ:MutableMapping[str, str]) -> dict[str, Optional[str]]
Extract CI tags from Github Actions environment.
funcddtrace.ext.git.extract_git_metadata(cwd:Optional[str]=None) -> dict[str, Optional[str]]
Extract git commit metadata.
funcddtrace.ext.sql.normalize_vendor(vendor:str) -> str
Return a canonical name for a type of database.
funcddtrace.internal.atexit.unregister(func:typing.Callable) -> None
Unregister *func* from atexit, handling the safe-wrapper indirection.
funcddtrace.internal.bytecode_injection.core.append_instruction(opcode:int, extended_arg:int) -> None
Append an operation and its argument to the new bytecode.
funcddtrace.internal.bytecode_injection.eject_hook(f:FunctionType, hook:HookType, line:int, arg:Any) -> FunctionType
Eject a hook from a function.
funcddtrace.internal.bytecode_injection.eject_hooks(f:FunctionType, hooks:list[HookInfoType]) -> list[HookInfoType]
Bulk-eject a list of hooks from a function.
funcddtrace.internal.bytecode_injection.inject_hook(f:FunctionType, hook:HookType, line:int, arg:Any) -> FunctionType
Inject a hook into a function.
funcddtrace.internal.bytecode_injection.inject_hooks(f:FunctionType, hooks:list[HookInfoType]) -> list[HookInfoType]
Bulk-inject a list of hooks into a function.
funcddtrace.internal.ci_visibility.coverage.segments(lines:Iterable[int]) -> list[tuple[int, int, int, int, int]]
Extract the relevant report data for a single file.
funcddtrace.internal.ci_visibility.service_registry.register_ci_visibility_instance(service:'CIVisibility') -> None
Register the CIVisibility service instance.
funcddtrace.internal.ci_visibility.service_registry.unregister_ci_visibility_instance() -> None
Unregister the current service instance.
funcddtrace.internal.ci_visibility.utils.combine_url_path(*args:str)
Combine URL path segments.
funcddtrace.internal.compat.ip_is_global(ip:str) -> bool
is_global is Python 3+ only.
funcddtrace.internal.compat.is_integer(obj:Any) -> bool
Helper to determine if the provided ``obj`` is an integer type or not
funcddtrace.internal.core.event_hub.dispatch_event(event:Event, allow_raise:bool=False) -> None
Call all hooks for the provided event.
funcddtrace.internal.core.find_item(data_key:str, default:Optional[Any]=None) -> Any
Find an item by its key, traversing up the context tree.
funcddtrace.internal.core.get_items(data_keys:list[str]) -> list[Optional[Any]]
Return multiple items by their keys, only in the local context.
classddtrace.internal.core.subscriber.ContextSubscriber
Base class for context event subscribers.
classddtrace.internal.core.subscriber.Subscriber
Base class for event subscribers.
classddtrace.internal.datastreams.processor.PathwayStats
Aggregated pathway statistics.
funcddtrace.internal.debug.collect(tracer_info:TracerDebugInfo) -> dict[str, Any]
Collect system and library information into a serializable dict.
classddtrace.internal.encoding.AgentlessTraceJSONEncoder
Buffered encoder for the agentless JSON trace intake.
classddtrace.internal.encoding.JSONEncoderV2
JSONEncoderV2 encodes traces to the new intake API format.
classddtrace.internal.endpoints.Singleton
Singleton Class.
funcddtrace.internal.excepthook.unregister(hook:ExceptHookType) -> None
Remove a previously registered callback.
classddtrace.internal.flare._subscribers.TracerFlareCallback
Remote config callback for tracer flare requests.
funcddtrace.internal.gitmetadata.clean_tags(tags:dict[str, str]) -> dict[str, str]
Cleanup tags from git metadata
funcddtrace.internal.iast.product.restart(join=False)
Restart the IAST product.
funcddtrace.internal.iast.product.start()
Start the IAST product.
funcddtrace.internal.iast.product.stop(join=False)
Stop the IAST product.
funcddtrace.internal.logger.set_tag_rate_limit(tag:str, rate:int) -> None
Set the rate limit for a specific tag.
classddtrace.internal.metrics.Metrics
Higher-level DogStatsD interface.
classddtrace.internal.module.BaseModuleWatchdog
Base module watchdog.
methodddtrace.internal.module.BaseModuleWatchdog.install() -> None
Install the module watchdog.
methodddtrace.internal.module.BaseModuleWatchdog.is_installed() -> bool
Check whether this module watchdog class is installed.
methodddtrace.internal.module.BaseModuleWatchdog.uninstall() -> None
Uninstall the module watchdog.
classddtrace.internal.module.ModuleWatchdog
Module watchdog.
methodddtrace.internal.module.ModuleWatchdog.get_by_origin(_origin:Path) -> t.Optional[ModuleType]
Lookup a module by its origin.
funcddtrace.internal.module.origin(module:ModuleType) -> t.Optional[Path]
Get the origin source file of the module.
funcddtrace.internal.module.register_post_run_module_hook(hook:ModuleHookType) -> None
Register a post run module hook.
funcddtrace.internal.module.register_run_module_transformer(transformer:TransformerType) -> None
Register a run module transformer.
funcddtrace.internal.module.unregister_post_run_module_hook(hook:ModuleHookType) -> None
Unregister a post run module hook.
funcddtrace.internal.module.unregister_run_module_transformer(transformer:TransformerType) -> None
Unregister a run module transformer.
classddtrace.internal.native_runtime.NativeRuntime
Manages a SharedRuntime with fork-safe lifecycle hooks.
methodddtrace.internal.native_runtime.NativeRuntime.shutdown(timeout_ms:Optional[int]=None) -> None
Shut down the shared Tokio runtime.
funcddtrace.internal.openfeature._agentless.build_agentless_endpoint(site:str, env:Optional[str]=None, base_url:Optional[str]=None) -> str
Build the agentless UFC endpoint URL.
classddtrace.internal.openfeature._flagevaluation_writer.FlagEvaluationWriter
SDK-native EVP `flagevaluation` writer.
classddtrace.internal.openfeature._provider.DataDogProvider
Datadog OpenFeature Provider.
methodddtrace.internal.openfeature._provider.DataDogProvider.clear_exposure_cache() -> None
Clear the exposure event cache.
methodddtrace.internal.openfeature._provider.DataDogProvider.get_metadata() -> Metadata
Returns provider metadata.
methodddtrace.internal.openfeature._provider.DataDogProvider.get_provider_hooks() -> list[typing.Any]
Returns provider-level hooks.
methodddtrace.internal.openfeature._provider.DataDogProvider.shutdown() -> None
Shutdown the provider.
classddtrace.internal.openfeature._span_enrichment.SpanEnrichmentState
Per-root-span accumulator.
classddtrace.internal.openfeature.writer.BatchedExposures
Batched exposure events with context.
classddtrace.internal.openfeature.writer.Context
Context information for batched exposures.
classddtrace.internal.openfeature.writer.ExposureEvent
Feature flag exposure event structure.
classddtrace.internal.openfeature.writer.ExposureWriter
Async writer for feature flag exposure events.
methodddtrace.internal.openfeature.writer.ExposureWriter.enqueue(event:ExposureEvent) -> None
Enqueue an exposure event to be sent to the intake.
methodddtrace.internal.openfeature.writer.ExposureWriter.periodic() -> None
Periodically flush buffered events to the intake.
classddtrace.internal.openfeature.writer.GeoContext
Geographic context information.
methodddtrace.internal.opentelemetry.span.Span.add_event(name, attributes=None, timestamp=None)
Records an event
methodddtrace.internal.opentelemetry.span.Span.end(end_time=None)
Marks the end time of a span.
methodddtrace.internal.opentelemetry.span.Span.kind()
Gets span kind attribute
methodddtrace.internal.opentelemetry.span.Span.set_attributes(attributes)
Sets attributes/tags
methodddtrace.internal.opentelemetry.span.Span.update_name(name)
Updates the name of a span
funcddtrace.internal.packages.get_version_for_package(name:str) -> str
returns the version of a package
funcddtrace.internal.packages.module_to_package(module:ModuleType) -> t.Optional[Distribution]
Returns the package distribution for a module
classddtrace.internal.periodic.PeriodicService
A service that runs periodically.
classddtrace.internal.rate_limiter.BudgetRateLimiterWithJitter
A budget rate limiter with jitter.
classddtrace.internal.rate_limiter.RateLimiter
A token bucket rate limiter implementation
classddtrace.internal.remoteconfig.ConfigMetadata
Configuration TUF target metadata
classddtrace.internal.remoteconfig.RCCallback
Base class for remote config callbacks.
methodddtrace.internal.remoteconfig.RCCallback.periodic() -> None
Method called at every polling operation.
classddtrace.internal.remoteconfig.worker.RemoteConfigPoller
Remote configuration worker.
methodddtrace.internal.remoteconfig.worker.RemoteConfigPoller.disable_product(product:'RemoteConfigProduct') -> None
Disable a product, removing it from client payloads.
methodddtrace.internal.remoteconfig.worker.RemoteConfigPoller.enable_product(product:'RemoteConfigProduct') -> None
Enable a product to be included in client payloads.
methodddtrace.internal.remoteconfig.worker.RemoteConfigPoller.get_registered(product:'RemoteConfigProduct') -> Optional[RCCallback]
Get the registered callback for a product.
methodddtrace.internal.remoteconfig.worker.RemoteConfigPoller.reset_at_fork() -> None
Refresh client state after a fork.
methodddtrace.internal.remoteconfig.worker.RemoteConfigPoller.unregister_callback(product:'RemoteConfigProduct') -> None
Unregister a product callback.
funcddtrace.internal.runtime.get_parent_runtime_id() -> t.Optional[str]
Return the runtime ID of the parent process.
funcddtrace.internal.runtime.get_runtime_id() -> str
Return a unique string identifier for this runtime.
classddtrace.internal.runtime.metric_collectors.PSUtilRuntimeMetricCollector
Collector for psutil metrics.
funcddtrace.internal.runtime.on_runtime_id_change(cb:t.Callable[[str], None]) -> None
Register a callback to be called when the runtime ID changes.
classddtrace.internal.runtime.tag_collectors.ProcessTagCollector
Tag collector for process tags.
classddtrace.internal.runtime.tag_collectors.TracerTagCollector
Tag collector for the ddtrace Tracer
classddtrace.internal.safety.SafeObjectProxy
Object proxy to make sure we don't call unsafe code.
methodddtrace.internal.safety.SafeObjectProxy.safe(obj:Any) -> Optional[Any]
Turn an object into a safe proxy.
funcddtrace.internal.safety.get_slots(obj:Any) -> set[str]
Get the object's slots.
funcddtrace.internal.sca.product.restart(join:bool=False) -> None
Handle fork scenarios by restarting SCA detection in child process.
funcddtrace.internal.sca.product.stop(join:bool=False) -> None
Cleanup SCA detection on shutdown.
classddtrace.internal.service.Service
A service that can be started or stopped.
methodddtrace.internal.service.Service.join(timeout:typing.Optional[float]=None) -> None
Join the service once stopped.
methodddtrace.internal.service.Service.start(*args:typing.Any, **kwargs:typing.Any) -> None
Start the service.
methodddtrace.internal.service.Service.stop(*args:typing.Any, **kwargs:typing.Any) -> None
Stop the service.
classddtrace.internal.service.ServiceStatus
A Service status.
funcddtrace.internal.settings.asm.build_libddwaf_filename() -> str
Build the filename of the libddwaf library to load.
classddtrace.internal.settings.env.EnvConfig
A MutableMapping wrapper around os.environ.
methodddtrace.internal.settings.http.HttpConfig.header_is_traced(header_name:str) -> bool
Returns whether or not the current header should be traced.
classddtrace.internal.settings.integration.Hooks
Deprecated no-op Hooks class for backwards compatibility.
classddtrace.internal.settings.integration.IntegrationConfig
Integration specific configuration object.
classddtrace.internal.sma.SimpleMovingAverage
Simple Moving Average implementation.
methodddtrace.internal.sma.SimpleMovingAverage.set(count:int, total:int) -> None
Set the value of the next bucket and update the SMA value.
classddtrace.internal.symbol_db.symbols.Scope
A scope is a collection of symbols.
methodddtrace.internal.symbol_db.symbols.Scope.from_module(module:ModuleType) -> 'Scope'
Get the scope of a module.
classddtrace.internal.symbol_db.symbols.Symbol
A symbol available from a scope.
classddtrace.internal.threads.PeriodicThread
A fork-safe periodic thread.
classddtrace.internal.uds.UDSHTTPConnection
An HTTP connection established over a Unix Domain Socket.
funcddtrace.internal.utils.cache.callonce(f:Callable[[], Any]) -> Callable[[], Any]
Decorator for executing a function only the first time.
funcddtrace.internal.utils.formats.asbool(value:Union[str, bool, None]) -> bool
Convert the given String to a boolean object.
funcddtrace.internal.utils.formats.format_trace_id(trace_id:int) -> str
Translate a trace ID to a string format supported by the backend.
classddtrace.internal.utils.http.MediaType
Body-parsing category for an HTTP ``Content-Type``.
funcddtrace.internal.utils.http.connector(url:str, **kwargs:Any) -> Connector
Create a connector context manager for the given URL.
funcddtrace.internal.utils.http.get_connection(url:str, timeout:float=DEFAULT_TIMEOUT) -> ConnectionType
Return an HTTP connection to the given URL.
funcddtrace.internal.utils.http.parse_form_params(body:str) -> dict[str, Union[str, list[str]]]
Return a dict of form data after HTTP form parsing
funcddtrace.internal.utils.http.strip_query_string(url:str) -> str
Strips the query string from a URL for use as tag in spans.
funcddtrace.internal.utils.importlib.func_name(f:Callable[..., Any]) -> str
Return a human readable version of the function's name.
funcddtrace.internal.utils.importlib.module_name(instance:Any) -> str
Return the instance module name.
funcddtrace.internal.utils.inspection.clear()
Clear the inspection state.
classddtrace.internal.utils.time.HourGlass
An implementation of an hourglass.
methodddtrace.internal.utils.time.HourGlass.trickling() -> bool
Check if sand is still trickling.
methodddtrace.internal.utils.time.HourGlass.turn() -> None
Turn the hourglass.
classddtrace.internal.utils.time.StopWatch
A simple timer/stopwatch helper class.
methodddtrace.internal.utils.time.StopWatch.elapsed() -> float
Get how many seconds have elapsed.
methodddtrace.internal.utils.time.StopWatch.start() -> 'StopWatch'
Starts the watch.
methodddtrace.internal.utils.time.StopWatch.stop() -> 'StopWatch'
Stops the watch.
funcddtrace.internal.uwsgi.check_uwsgi(worker_callback:Optional[Callable]=None, atexit:Optional[Callable]=None) -> None
Check whetever uwsgi is running and what needs to be done.
classddtrace.internal.uwsgi.uWSGIConfigDeprecationWarning
uWSGI configuration deprecation warning.
classddtrace.internal.uwsgi.uWSGIConfigError
uWSGI configuration error.
classddtrace.internal.uwsgi.uWSGIMasterProcess
The process is uWSGI master process.
classddtrace.internal.wrapping.WrappedFunction
A wrapped function.
classddtrace.internal.wrapping.context.ContextWrappedFunction
A wrapped function.
funcddtrace.internal.wrapping.generate_posargs(code:CodeType) -> Iterator[Any]
Generate the opcodes for building the positional arguments tuple.
funcddtrace.internal.wrapping.is_wrapped(f:FunctionType) -> bool
Check if a function is wrapped with any wrapper.
funcddtrace.internal.wrapping.is_wrapped_with(f:FunctionType, wrapper:Wrapper) -> bool
Check if a function is wrapped with a specific wrapper.
funcddtrace.internal.wrapping.unwrap(wf:WrappedFunction, wrapper:Wrapper) -> FunctionType
Unwrap a wrapped function.
funcddtrace.internal.wrapping.wrap(f:FunctionType, wrapper:Wrapper) -> WrappedFunction
Wrap a function with a wrapper.
funcddtrace.internal.wrapping.wrap_bytecode(wrapper:Wrapper, wrapped:FunctionType) -> bc.Bytecode
Wrap a function with a wrapper function.
classddtrace.internal.writer.writer.AgentlessTraceWriter
HTTP writer for agentless JSON span intake.
classddtrace.internal.writer.writer.HTTPWriter
Writer to an arbitrary HTTP intake endpoint.
classddtrace.internal.writer.writer_client.AgentlessWriterClient
Client for the agentless span intake (api/v2/spans).
classddtrace.llmobs._constants.LLMOBS_STRUCT
Nested LLMObs struct keys in span._meta_struct.
classddtrace.llmobs._constants.LLMObsExportMode
The primary path LLMObs span data takes to Datadog.
classddtrace.llmobs._evaluators.format.JSONEvaluator
Evaluator that validates if output is valid JSON.
methodddtrace.llmobs._evaluators.format.JSONEvaluator.evaluate(context:EvaluatorContext) -> EvaluatorResult
Perform JSON validation.
classddtrace.llmobs._evaluators.format.LengthEvaluator
Evaluator that validates output length constraints.
methodddtrace.llmobs._evaluators.format.LengthEvaluator.evaluate(context:EvaluatorContext) -> EvaluatorResult
Perform length validation.
classddtrace.llmobs._evaluators.llm_judge.BaseStructuredOutput
Abstract base class for LLM Judge structured outputs.
methodddtrace.llmobs._evaluators.llm_judge.BaseStructuredOutput.label() -> str
Return the label key for the evaluation result.
methodddtrace.llmobs._evaluators.semantic.SemanticSimilarityEvaluator.evaluate(context:EvaluatorContext) -> EvaluatorResult
Perform semantic similarity evaluation.
classddtrace.llmobs._evaluators.string_matching.RegexMatchEvaluator
Evaluator that performs regex pattern matching.
methodddtrace.llmobs._evaluators.string_matching.RegexMatchEvaluator.evaluate(context:EvaluatorContext) -> EvaluatorResult
Perform regex match evaluation.
classddtrace.llmobs._experiment.BaseAsyncEvaluator
Base class for async row-level evaluators.
methodddtrace.llmobs._experiment.BaseAsyncEvaluator.evaluate(context:EvaluatorContext) -> Union[JSONType, EvaluatorResult, MultiEvaluatorResult]
Perform async evaluation.
classddtrace.llmobs._experiment.BaseEvaluator
This class provides a unified interface for evaluators.
methodddtrace.llmobs._experiment.BaseEvaluator.evaluate(context:EvaluatorContext) -> Union[JSONType, EvaluatorResult, 'MultiEvaluatorResult']
Perform evaluation.
methodddtrace.llmobs._experiment.Dataset.add_tags(index:int, tags:list[str]) -> None
Add tags to an existing record.

About this data

These signatures were extracted from the public source of DataDog/dd-trace-py using Python's ast module. Argument names, default values, type annotations and return types are taken verbatim from the code. Implementation bodies are never stored. See how it works for details.

Back to all 805 libraries