SYMBOL INDEX (926 symbols across 125 files)

FILE: aws_xray_sdk/core/async_context.py
  class AsyncContext (line 7) | class AsyncContext(_Context):
    method __init__ (line 15) | def __init__(self, *args, loop=None, use_task_factory=True, **kwargs):
    method clear_trace_entities (line 27) | def clear_trace_entities(self):
  class TaskLocalStorage (line 35) | class TaskLocalStorage:
    method __init__ (line 39) | def __init__(self, loop=None):
    method __setattr__ (line 44) | def __setattr__(self, name, value):
    method __getattribute__ (line 60) | def __getattribute__(self, item):
    method clear (line 74) | def clear(self):
  function task_factory (line 81) | def task_factory(loop, coro):

FILE: aws_xray_sdk/core/async_recorder.py
  class AsyncSegmentContextManager (line 9) | class AsyncSegmentContextManager(SegmentContextManager):
    method __aenter__ (line 10) | async def __aenter__(self):
    method __aexit__ (line 13) | async def __aexit__(self, exc_type, exc_val, exc_tb):
  class AsyncSubsegmentContextManager (line 16) | class AsyncSubsegmentContextManager(SubsegmentContextManager):
    method __call__ (line 19) | async def __call__(self, wrapped, instance, args, kwargs):
    method __aenter__ (line 36) | async def __aenter__(self):
    method __aexit__ (line 39) | async def __aexit__(self, exc_type, exc_val, exc_tb):
  class AsyncAWSXRayRecorder (line 43) | class AsyncAWSXRayRecorder(AWSXRayRecorder):
    method capture_async (line 44) | def capture_async(self, name=None):
    method in_segment_async (line 54) | def in_segment_async(self, name=None, **segment_kwargs):
    method in_subsegment_async (line 63) | def in_subsegment_async(self, name=None, **subsegment_kwargs):
    method record_subsegment_async (line 72) | async def record_subsegment_async(self, wrapped, instance, args, kwarg...

FILE: aws_xray_sdk/core/context.py
  class Context (line 17) | class Context:
    method __init__ (line 30) | def __init__(self, context_missing='LOG_ERROR'):
    method put_segment (line 36) | def put_segment(self, segment):
    method end_segment (line 43) | def end_segment(self, end_time=None):
    method put_subsegment (line 59) | def put_subsegment(self, subsegment):
    method end_subsegment (line 73) | def end_subsegment(self, end_time=None):
    method get_trace_entity (line 92) | def get_trace_entity(self):
    method set_trace_entity (line 105) | def set_trace_entity(self, trace_entity):
    method clear_trace_entities (line 112) | def clear_trace_entities(self):
    method handle_context_missing (line 120) | def handle_context_missing(self):
    method _is_subsegment (line 129) | def _is_subsegment(self, entity):
    method context_missing (line 134) | def context_missing(self):
    method context_missing (line 138) | def context_missing(self, value):

FILE: aws_xray_sdk/core/daemon_config.py
  class DaemonConfig (line 9) | class DaemonConfig:
    method __init__ (line 20) | def __init__(self, daemon_address=DEFAULT_ADDRESS):
    method _parse_single_form (line 33) | def _parse_single_form(self, val):
    method _parse_double_form (line 43) | def _parse_double_form(self, val1, val2, origin):
    method udp_ip (line 63) | def udp_ip(self):
    method udp_port (line 67) | def udp_port(self):
    method tcp_ip (line 71) | def tcp_ip(self):
    method tcp_port (line 75) | def tcp_port(self):

FILE: aws_xray_sdk/core/emitters/udp_emitter.py
  class UDPEmitter (line 15) | class UDPEmitter:
    method __init__ (line 22) | def __init__(self, daemon_address=DEFAULT_DAEMON_ADDRESS):
    method send_entity (line 28) | def send_entity(self, entity):
    method set_daemon_address (line 45) | def set_daemon_address(self, address):
    method ip (line 55) | def ip(self):
    method port (line 59) | def port(self):
    method _send_data (line 62) | def _send_data(self, data):
    method _parse_address (line 65) | def _parse_address(self, daemon_address):

FILE: aws_xray_sdk/core/exceptions/exceptions.py
  class InvalidSamplingManifestError (line 1) | class InvalidSamplingManifestError(Exception):
  class SegmentNotFoundException (line 5) | class SegmentNotFoundException(Exception):
  class InvalidDaemonAddressException (line 9) | class InvalidDaemonAddressException(Exception):
  class SegmentNameMissingException (line 13) | class SegmentNameMissingException(Exception):
  class SubsegmentNameMissingException (line 17) | class SubsegmentNameMissingException(Exception):
  class FacadeSegmentMutationException (line 21) | class FacadeSegmentMutationException(Exception):
  class MissingPluginNames (line 25) | class MissingPluginNames(Exception):
  class AlreadyEndedException (line 29) | class AlreadyEndedException(Exception):

FILE: aws_xray_sdk/core/lambda_launcher.py
  function check_in_lambda (line 20) | def check_in_lambda():
  class LambdaContext (line 44) | class LambdaContext(Context):
    method __init__ (line 51) | def __init__(self):
    method put_segment (line 55) | def put_segment(self, segment):
    method end_segment (line 61) | def end_segment(self, end_time=None):
    method put_subsegment (line 67) | def put_subsegment(self, subsegment):
    method set_trace_entity (line 82) | def set_trace_entity(self, trace_entity):
    method get_trace_entity (line 94) | def get_trace_entity(self):
    method _refresh_context (line 101) | def _refresh_context(self):
    method context_missing (line 125) | def context_missing(self):
    method context_missing (line 129) | def context_missing(self, value):
    method handle_context_missing (line 132) | def handle_context_missing(self):
    method _initialize_context (line 138) | def _initialize_context(self, trace_header):

FILE: aws_xray_sdk/core/models/default_dynamic_naming.py
  class DefaultDynamicNaming (line 4) | class DefaultDynamicNaming:
    method __init__ (line 12) | def __init__(self, pattern, fallback):
    method get_name (line 24) | def get_name(self, host_name):

FILE: aws_xray_sdk/core/models/dummy_entities.py
  class DummySegment (line 8) | class DummySegment(Segment):
    method __init__ (line 18) | def __init__(self, name='dummy'):
    method set_aws (line 26) | def set_aws(self, aws_meta):
    method put_http_meta (line 32) | def put_http_meta(self, key, value):
    method put_annotation (line 38) | def put_annotation(self, key, value):
    method put_metadata (line 44) | def put_metadata(self, key, value, namespace='default'):
    method set_user (line 50) | def set_user(self, user):
    method set_service (line 56) | def set_service(self, service_info):
    method apply_status_code (line 62) | def apply_status_code(self, status_code):
    method add_exception (line 68) | def add_exception(self, exception, stack, remote=False):
    method serialize (line 74) | def serialize(self):
  class DummySubsegment (line 81) | class DummySubsegment(Subsegment):
    method __init__ (line 89) | def __init__(self, segment, name='dummy'):
    method set_aws (line 98) | def set_aws(self, aws_meta):
    method put_http_meta (line 104) | def put_http_meta(self, key, value):
    method put_annotation (line 110) | def put_annotation(self, key, value):
    method put_metadata (line 116) | def put_metadata(self, key, value, namespace='default'):
    method set_sql (line 122) | def set_sql(self, sql):
    method apply_status_code (line 128) | def apply_status_code(self, status_code):
    method add_exception (line 134) | def add_exception(self, exception, stack, remote=False):
    method serialize (line 140) | def serialize(self):

FILE: aws_xray_sdk/core/models/entity.py
  class Entity (line 24) | class Entity:
    method __init__ (line 30) | def __init__(self, name, entity_id=None):
    method close (line 62) | def close(self, end_time=None):
    method add_subsegment (line 78) | def add_subsegment(self, subsegment):
    method remove_subsegment (line 90) | def remove_subsegment(self, subsegment):
    method put_http_meta (line 96) | def put_http_meta(self, key, value):
    method put_annotation (line 131) | def put_annotation(self, key, value):
    method put_metadata (line 156) | def put_metadata(self, key, value, namespace='default'):
    method set_aws (line 181) | def set_aws(self, aws_meta):
    method add_throttle_flag (line 191) | def add_throttle_flag(self):
    method add_fault_flag (line 194) | def add_fault_flag(self):
    method add_error_flag (line 197) | def add_error_flag(self):
    method apply_status_code (line 200) | def apply_status_code(self, status_code):
    method add_exception (line 218) | def add_exception(self, exception, stack, remote=False):
    method save_origin_trace_header (line 250) | def save_origin_trace_header(self, trace_header):
    method get_origin_trace_header (line 258) | def get_origin_trace_header(self):
    method serialize (line 264) | def serialize(self):
    method to_dict (line 271) | def to_dict(self):
    method _check_ended (line 304) | def _check_ended(self):
    method _generate_random_id (line 308) | def _generate_random_id(self):

FILE: aws_xray_sdk/core/models/facade_segment.py
  class FacadeSegment (line 8) | class FacadeSegment(Segment):
    method __init__ (line 17) | def __init__(self, name, entityid, traceid, sampled):
    method close (line 32) | def close(self, end_time=None):
    method put_http_meta (line 38) | def put_http_meta(self, key, value):
    method put_annotation (line 44) | def put_annotation(self, key, value):
    method put_metadata (line 50) | def put_metadata(self, key, value, namespace='default'):
    method set_aws (line 56) | def set_aws(self, aws_meta):
    method set_user (line 62) | def set_user(self, user):
    method add_throttle_flag (line 68) | def add_throttle_flag(self):
    method add_fault_flag (line 74) | def add_fault_flag(self):
    method add_error_flag (line 80) | def add_error_flag(self):
    method add_exception (line 86) | def add_exception(self, exception, stack, remote=False):
    method apply_status_code (line 92) | def apply_status_code(self, status_code):
    method serialize (line 98) | def serialize(self):
    method ready_to_send (line 104) | def ready_to_send(self):
    method increment (line 111) | def increment(self):
    method decrement_ref_counter (line 117) | def decrement_ref_counter(self):
    method _is_initializing (line 123) | def _is_initializing(self, entityid, traceid, sampled):

FILE: aws_xray_sdk/core/models/noop_traceid.py
  class NoOpTraceId (line 1) | class NoOpTraceId:
    method __init__ (line 10) | def __init__(self):
    method to_id (line 17) | def to_id(self):

FILE: aws_xray_sdk/core/models/segment.py
  class SegmentContextManager (line 12) | class SegmentContextManager:
    method __init__ (line 17) | def __init__(self, recorder, name=None, **segment_kwargs):
    method __enter__ (line 23) | def __enter__(self):
    method __exit__ (line 28) | def __exit__(self, exc_type, exc_val, exc_tb):
  class Segment (line 43) | class Segment(Entity):
    method __init__ (line 49) | def __init__(self, name, entityid=None, traceid=None,
    method add_subsegment (line 83) | def add_subsegment(self, subsegment):
    method increment (line 91) | def increment(self):
    method decrement_ref_counter (line 100) | def decrement_ref_counter(self):
    method ready_to_send (line 106) | def ready_to_send(self):
    method get_total_subsegments_size (line 113) | def get_total_subsegments_size(self):
    method decrement_subsegments_size (line 119) | def decrement_subsegments_size(self):
    method remove_subsegment (line 126) | def remove_subsegment(self, subsegment):
    method set_user (line 133) | def set_user(self, user):
    method set_service (line 141) | def set_service(self, service_info):
    method set_rule_name (line 148) | def set_rule_name(self, rule_name):
    method to_dict (line 158) | def to_dict(self):

FILE: aws_xray_sdk/core/models/subsegment.py
  function set_as_recording (line 14) | def set_as_recording(decorated_func, wrapped):
  function is_already_recording (line 19) | def is_already_recording(func):
  function subsegment_decorator (line 26) | def subsegment_decorator(wrapped, instance, args, kwargs):
  class SubsegmentContextManager (line 32) | class SubsegmentContextManager:
    method __init__ (line 37) | def __init__(self, recorder, name=None, **subsegment_kwargs):
    method __call__ (line 44) | def __call__(self, wrapped, instance, args, kwargs):
    method __enter__ (line 61) | def __enter__(self):
    method __exit__ (line 66) | def __exit__(self, exc_type, exc_val, exc_tb):
  class Subsegment (line 81) | class Subsegment(Entity):
    method __init__ (line 89) | def __init__(self, name, namespace, segment):
    method add_subsegment (line 111) | def add_subsegment(self, subsegment):
    method remove_subsegment (line 120) | def remove_subsegment(self, subsegment):
    method close (line 130) | def close(self, end_time=None):
    method set_sql (line 142) | def set_sql(self, sql):
    method to_dict (line 152) | def to_dict(self):

FILE: aws_xray_sdk/core/models/throwable.py
  class Throwable (line 9) | class Throwable:
    method __init__ (line 15) | def __init__(self, exception, stack, remote=False):
    method to_dict (line 48) | def to_dict(self):
    method _normalize_stack_trace (line 61) | def _normalize_stack_trace(self, stack):

FILE: aws_xray_sdk/core/models/trace_header.py
  class TraceHeader (line 13) | class TraceHeader:
    method __init__ (line 21) | def __init__(self, root=None, parent=None, sampled=None, data=None):
    method from_header_str (line 42) | def from_header_str(cls, header):
    method to_header_str (line 75) | def to_header_str(self):
    method root (line 94) | def root(self):
    method parent (line 101) | def parent(self):
    method sampled (line 108) | def sampled(self):
    method data (line 116) | def data(self):

FILE: aws_xray_sdk/core/models/traceid.py
  class TraceId (line 6) | class TraceId:
    method __init__ (line 15) | def __init__(self):
    method to_id (line 22) | def to_id(self):

FILE: aws_xray_sdk/core/patcher.py
  function patch_all (line 51) | def patch_all(double_patch=False):
  function _is_valid_import (line 70) | def _is_valid_import(module):
  function patch (line 82) | def patch(modules_to_patch, raise_errors=True, ignore_module_patterns=No...
  function _patch_module (line 130) | def _patch_module(module_to_patch, raise_errors=True):
  function _patch (line 139) | def _patch(module_to_patch):
  function _patch_func (line 154) | def _patch_func(parent, func_name, func, modifier=lambda x: x):
  function _patch_class (line 167) | def _patch_class(module, cls):
  function _on_import (line 193) | def _on_import(module):
  function _external_module_patch (line 205) | def _external_module_patch(module, ignore_module_patterns):

FILE: aws_xray_sdk/core/plugins/ec2_plugin.py
  function initialize (line 12) | def initialize():
  function get_token (line 27) | def get_token():
  function get_metadata (line 43) | def get_metadata(token=None):
  function parse_metadata_json (line 59) | def parse_metadata_json(json_str):
  function do_request (line 71) | def do_request(url, headers=None, method="GET"):

FILE: aws_xray_sdk/core/plugins/ecs_plugin.py
  function initialize (line 10) | def initialize():

FILE: aws_xray_sdk/core/plugins/elasticbeanstalk_plugin.py
  function initialize (line 11) | def initialize():

FILE: aws_xray_sdk/core/plugins/utils.py
  function get_plugin_modules (line 13) | def get_plugin_modules(plugins):

FILE: aws_xray_sdk/core/recorder.py
  class AWSXRayRecorder (line 42) | class AWSXRayRecorder:
    method __init__ (line 52) | def __init__(self):
    method configure (line 80) | def configure(self, sampling=None, plugins=None,
    method in_segment (line 186) | def in_segment(self, name=None, **segment_kwargs):
    method in_subsegment (line 195) | def in_subsegment(self, name=None, **subsegment_kwargs):
    method begin_segment (line 204) | def begin_segment(self, name=None, traceid=None,
    method end_segment (line 247) | def end_segment(self, end_time=None):
    method current_segment (line 264) | def current_segment(self):
    method _begin_subsegment_helper (line 277) | def _begin_subsegment_helper(self, name, namespace='local', beginWitho...
    method begin_subsegment (line 303) | def begin_subsegment(self, name, namespace='local'):
    method begin_subsegment_without_sampling (line 316) | def begin_subsegment_without_sampling(self, name):
    method current_subsegment (line 327) | def current_subsegment(self):
    method end_subsegment (line 342) | def end_subsegment(self, end_time=None):
    method put_annotation (line 362) | def put_annotation(self, key, value):
    method put_metadata (line 377) | def put_metadata(self, key, value, namespace='default'):
    method is_sampled (line 394) | def is_sampled(self):
    method get_trace_entity (line 407) | def get_trace_entity(self):
    method set_trace_entity (line 413) | def set_trace_entity(self, trace_entity):
    method clear_trace_entities (line 419) | def clear_trace_entities(self):
    method stream_subsegments (line 425) | def stream_subsegments(self):
    method capture (line 436) | def capture(self, name=None):
    method record_subsegment (line 446) | def record_subsegment(self, wrapped, instance, args, kwargs, name,
    method _populate_runtime_context (line 482) | def _populate_runtime_context(self, segment, sampling_decision):
    method _send_segment (line 492) | def _send_segment(self):
    method _stream_subsegment_out (line 507) | def _stream_subsegment_out(self, subsegment):
    method _load_sampling_rules (line 512) | def _load_sampling_rules(self, sampling_rules):
    method _is_subsegment (line 523) | def _is_subsegment(self, entity):
    method enabled (line 528) | def enabled(self):
    method enabled (line 532) | def enabled(self, value):
    method sampling (line 536) | def sampling(self):
    method sampling (line 540) | def sampling(self, value):
    method sampler (line 544) | def sampler(self):
    method sampler (line 548) | def sampler(self, value):
    method service (line 552) | def service(self):
    method service (line 556) | def service(self, value):
    method dynamic_naming (line 560) | def dynamic_naming(self):
    method dynamic_naming (line 564) | def dynamic_naming(self, value):
    method context (line 571) | def context(self):
    method context (line 575) | def context(self, cxt):
    method emitter (line 579) | def emitter(self):
    method emitter (line 583) | def emitter(self, value):
    method streaming (line 587) | def streaming(self):
    method streaming (line 591) | def streaming(self, value):
    method streaming_threshold (line 595) | def streaming_threshold(self):
    method streaming_threshold (line 602) | def streaming_threshold(self, value):
    method max_trace_back (line 609) | def max_trace_back(self):
    method max_trace_back (line 613) | def max_trace_back(self, value):
    method stream_sql (line 617) | def stream_sql(self):
    method stream_sql (line 621) | def stream_sql(self, value):

FILE: aws_xray_sdk/core/sampling/connector.py
  class ServiceConnector (line 15) | class ServiceConnector:
    method __init__ (line 21) | def __init__(self):
    method _context_wrapped (line 26) | def _context_wrapped(func):
    method fetch_sampling_rules (line 48) | def fetch_sampling_rules(self):
    method fetch_sampling_target (line 75) | def fetch_sampling_target(self, rules):
    method setup_xray_client (line 101) | def setup_xray_client(self, ip, port, client):
    method context (line 112) | def context(self):
    method context (line 116) | def context(self, v):
    method _generate_reporting_docs (line 119) | def _generate_reporting_docs(self, rules, now):
    method _dt_to_epoch (line 135) | def _dt_to_epoch(self, dt):
    method _is_rule_valid (line 142) | def _is_rule_valid(self, record):
    method _create_xray_client (line 149) | def _create_xray_client(self, ip='127.0.0.1', port='2000'):

FILE: aws_xray_sdk/core/sampling/local/reservoir.py
  class Reservoir (line 5) | class Reservoir:
    method __init__ (line 11) | def __init__(self, traces_per_sec=0):
    method take (line 21) | def take(self):

FILE: aws_xray_sdk/core/sampling/local/sampler.py
  class LocalSampler (line 14) | class LocalSampler:
    method __init__ (line 21) | def __init__(self, rules=local_sampling_rule):
    method should_trace (line 52) | def should_trace(self, sampling_req=None):
    method load_local_rules (line 75) | def load_local_rules(self, rules):
    method _should_trace (line 92) | def _should_trace(self, sampling_rule):

FILE: aws_xray_sdk/core/sampling/local/sampling_rule.py
  class SamplingRule (line 6) | class SamplingRule:
    method __init__ (line 19) | def __init__(self, rule_dict, version=2, default=False):
    method applies (line 43) | def applies(self, host, method, path):
    method fixed_target (line 54) | def fixed_target(self):
    method rate (line 62) | def rate(self):
    method host (line 69) | def host(self):
    method method (line 76) | def method(self):
    method path (line 83) | def path(self):
    method reservoir (line 90) | def reservoir(self):
    method version (line 97) | def version(self):
    method _validate (line 103) | def _validate(self):

FILE: aws_xray_sdk/core/sampling/reservoir.py
  class Reservoir (line 5) | class Reservoir:
    method __init__ (line 10) | def __init__(self):
    method borrow_or_take (line 23) | def borrow_or_take(self, now, can_borrow):
    method load_quota (line 32) | def load_quota(self, quota, TTL, interval):
    method quota (line 46) | def quota(self):
    method TTL (line 50) | def TTL(self):
    method _time_to_report (line 53) | def _time_to_report(self):
    method _borrow_or_take (line 60) | def _borrow_or_take(self, now, can_borrow):
    method _adjust_this_sec (line 79) | def _adjust_this_sec(self, now):
  class ReservoirDecision (line 86) | class ReservoirDecision(Enum):

FILE: aws_xray_sdk/core/sampling/rule_cache.py
  class RuleCache (line 7) | class RuleCache:
    method __init__ (line 12) | def __init__(self):
    method get_matched_rule (line 18) | def get_matched_rule(self, sampling_req, now):
    method load_rules (line 29) | def load_rules(self, rules):
    method load_targets (line 34) | def load_targets(self, targets_dict):
    method _load_rules (line 38) | def _load_rules(self, rules):
    method _load_targets (line 57) | def _load_targets(self, targets_dict):
    method _is_expired (line 66) | def _is_expired(self, now):
    method rules (line 73) | def rules(self):
    method rules (line 77) | def rules(self, v):
    method last_updated (line 81) | def last_updated(self):
    method last_updated (line 85) | def last_updated(self, v):

FILE: aws_xray_sdk/core/sampling/rule_poller.py
  class RulePoller (line 11) | class RulePoller:
    method __init__ (line 13) | def __init__(self, cache, connector):
    method start (line 21) | def start(self):
    method _worker (line 26) | def _worker(self):
    method wake_up (line 37) | def wake_up(self):
    method _refresh_cache (line 45) | def _refresh_cache(self):
    method _reset_time_to_wait (line 55) | def _reset_time_to_wait(self):

FILE: aws_xray_sdk/core/sampling/sampler.py
  class DefaultSampler (line 17) | class DefaultSampler:
    method __init__ (line 22) | def __init__(self):
    method start (line 36) | def start(self):
    method should_trace (line 50) | def should_trace(self, sampling_req=None):
    method load_local_rules (line 77) | def load_local_rules(self, rules):
    method load_settings (line 83) | def load_settings(self, daemon_config, context, origin=None):
    method _process_matched_rule (line 98) | def _process_matched_rule(self, rule, now):
    method xray_client (line 121) | def xray_client(self):
    method xray_client (line 125) | def xray_client(self, v):

FILE: aws_xray_sdk/core/sampling/sampling_rule.py
  class SamplingRule (line 7) | class SamplingRule:
    method __init__ (line 11) | def __init__(self, name, priority, rate, reservoir_size,
    method match (line 30) | def match(self, sampling_req):
    method is_default (line 51) | def is_default(self):
    method snapshot_statistics (line 55) | def snapshot_statistics(self):
    method merge (line 71) | def merge(self, rule):
    method ever_matched (line 82) | def ever_matched(self):
    method time_to_report (line 89) | def time_to_report(self):
    method increment_request_count (line 96) | def increment_request_count(self):
    method increment_borrow_count (line 100) | def increment_borrow_count(self):
    method increment_sampled_count (line 104) | def increment_sampled_count(self):
    method _reset_statistics (line 108) | def _reset_statistics(self):
    method rate (line 114) | def rate(self):
    method rate (line 118) | def rate(self, v):
    method name (line 122) | def name(self):
    method priority (line 126) | def priority(self):
    method reservoir (line 130) | def reservoir(self):
    method reservoir (line 134) | def reservoir(self, v):
    method can_borrow (line 138) | def can_borrow(self):
    method request_count (line 142) | def request_count(self):
    method borrow_count (line 146) | def borrow_count(self):
    method sampled_count (line 150) | def sampled_count(self):

FILE: aws_xray_sdk/core/sampling/target_poller.py
  class TargetPoller (line 9) | class TargetPoller:
    method __init__ (line 15) | def __init__(self, cache, rule_poller, connector):
    method start (line 22) | def start(self):
    method _worker (line 27) | def _worker(self):
    method _do_work (line 35) | def _do_work(self):
    method _get_candidates (line 47) | def _get_candidates(self, all_rules):
    method _get_jitter (line 59) | def _get_jitter(self):

FILE: aws_xray_sdk/core/streaming/default_streaming.py
  class DefaultStreaming (line 4) | class DefaultStreaming:
    method __init__ (line 10) | def __init__(self, streaming_threshold=30):
    method is_eligible (line 14) | def is_eligible(self, segment):
    method stream (line 24) | def stream(self, entity, callback):
    method _stream (line 35) | def _stream(self, entity, callback):
    method streaming_threshold (line 57) | def streaming_threshold(self):
    method streaming_threshold (line 61) | def streaming_threshold(self, value):

FILE: aws_xray_sdk/core/utils/atomic_counter.py
  class AtomicCounter (line 4) | class AtomicCounter:
    method __init__ (line 8) | def __init__(self, initial=0):
    method increment (line 14) | def increment(self, num=1):
    method decrement (line 20) | def decrement(self, num=1):
    method get_current (line 26) | def get_current(self):
    method reset (line 31) | def reset(self):

FILE: aws_xray_sdk/core/utils/compat.py
  function is_classmethod (line 6) | def is_classmethod(func):
  function is_instance_method (line 10) | def is_instance_method(parent_class, func_name, func):

FILE: aws_xray_sdk/core/utils/conversion.py
  function metadata_to_dict (line 5) | def metadata_to_dict(obj):

FILE: aws_xray_sdk/core/utils/search_pattern.py
  function wildcard_match (line 1) | def wildcard_match(pattern, text, case_insensitive=True):

FILE: aws_xray_sdk/core/utils/sqs_message_helper.py
  class SqsMessageHelper (line 2) | class SqsMessageHelper:
    method isSampled (line 5) | def isSampled(sqs_message):

FILE: aws_xray_sdk/core/utils/stacktrace.py
  function get_stacktrace (line 5) | def get_stacktrace(limit=None):

FILE: aws_xray_sdk/ext/aiobotocore/patch.py
  function patch (line 8) | def patch():
  function _xray_traced_aiobotocore (line 30) | async def _xray_traced_aiobotocore(wrapped, instance, args, kwargs):

FILE: aws_xray_sdk/ext/aiohttp/client.py
  function begin_subsegment (line 24) | async def begin_subsegment(session, trace_config_ctx, params):
  function end_subsegment (line 38) | async def end_subsegment(session, trace_config_ctx, params):
  function end_subsegment_with_exception (line 47) | async def end_subsegment_with_exception(session, trace_config_ctx, params):
  function aws_xray_trace_config (line 63) | def aws_xray_trace_config(name=None):

FILE: aws_xray_sdk/ext/aiohttp/middleware.py
  function middleware (line 15) | async def middleware(request, handler):

FILE: aws_xray_sdk/ext/boto_utils.py
  function inject_header (line 16) | def inject_header(wrapped, instance, args, kwargs):
  function aws_meta_processor (line 35) | def aws_meta_processor(wrapped, instance, args, kwargs,
  function _aws_error_handler (line 68) | def _aws_error_handler(exception, stack, subsegment, aws_meta):
  function _extract_whitelisted_params (line 86) | def _extract_whitelisted_params(service, operation,
  function _record_params (line 115) | def _record_params(whitelisted, actual, aws_meta):
  function _record_special_params (line 123) | def _record_special_params(whitelisted, actual, aws_meta):
  function _process_descriptor (line 130) | def _process_descriptor(descriptor, value, aws_meta):

FILE: aws_xray_sdk/ext/botocore/patch.py
  function patch (line 8) | def patch():
  function _xray_traced_botocore (line 30) | def _xray_traced_botocore(wrapped, instance, args, kwargs):

FILE: aws_xray_sdk/ext/bottle/middleware.py
  class XRayMiddleware (line 10) | class XRayMiddleware:
    method __init__ (line 17) | def __init__(self, recorder):
    method apply (line 26) | def apply(self, callback, route):
  function _patch_render (line 101) | def _patch_render(recorder):

FILE: aws_xray_sdk/ext/dbapi2.py
  class XRayTracedConn (line 7) | class XRayTracedConn(wrapt.ObjectProxy):
    method __init__ (line 11) | def __init__(self, conn, meta={}):
    method cursor (line 16) | def cursor(self, *args, **kwargs):
  class XRayTracedCursor (line 22) | class XRayTracedCursor(wrapt.ObjectProxy):
    method __init__ (line 26) | def __init__(self, cursor, meta={}):
    method __enter__ (line 36) | def __enter__(self):
    method execute (line 44) | def execute(self, query, *args, **kwargs):
    method executemany (line 50) | def executemany(self, query, *args, **kwargs):
    method callproc (line 56) | def callproc(self, proc, args):
  function add_sql_meta (line 62) | def add_sql_meta(meta):

FILE: aws_xray_sdk/ext/django/apps.py
  class XRayConfig (line 15) | class XRayConfig(AppConfig):
    method ready (line 18) | def ready(self):

FILE: aws_xray_sdk/ext/django/conf.py
  class XRaySettings (line 33) | class XRaySettings:
    method __init__ (line 39) | def __init__(self, user_settings=None):
    method user_settings (line 47) | def user_settings(self):
    method __getattr__ (line 54) | def __getattr__(self, attr):
  function reload_settings (line 73) | def reload_settings(*args, **kwargs):

FILE: aws_xray_sdk/ext/django/db.py
  function patch_db (line 13) | def patch_db():
  class DjangoXRayTracedCursor (line 19) | class DjangoXRayTracedCursor(XRayTracedCursor):
    method execute (line 20) | def execute(self, query, *args, **kwargs):
    method executemany (line 29) | def executemany(self, query, *args, **kwargs):
    method callproc (line 38) | def callproc(self, proc, args):
  function _patch_cursor (line 48) | def _patch_cursor(cursor_name, conn):
  function _patch_conn (line 87) | def _patch_conn(conn):

FILE: aws_xray_sdk/ext/django/middleware.py
  class XRayMiddleware (line 22) | class XRayMiddleware:
    method __init__ (line 26) | def __init__(self, get_response):
    method _urls_as_annotation (line 34) | def _urls_as_annotation(self):
    method __call__ (line 43) | def __call__(self, request):
    method process_exception (line 117) | def process_exception(self, request, exception):

FILE: aws_xray_sdk/ext/django/templates.py
  function patch_template (line 11) | def patch_template():

FILE: aws_xray_sdk/ext/flask/middleware.py
  class XRayMiddleware (line 11) | class XRayMiddleware:
    method __init__ (line 13) | def __init__(self, app, recorder):
    method _before_request (line 28) | def _before_request(self):
    method _after_request (line 69) | def _after_request(self, response):
    method _teardown_request (line 86) | def _teardown_request(self, exception):
  function _patch_render (line 109) | def _patch_render(recorder):

FILE: aws_xray_sdk/ext/flask_sqlalchemy/query.py
  class XRayBaseQuery (line 10) | class XRayBaseQuery(BaseQuery):
  class XRaySignallingSession (line 14) | class XRaySignallingSession(XRaySession):
    method __init__ (line 27) | def __init__(self, db, autocommit=False, autoflush=True, **options):
    method get_bind (line 42) | def get_bind(self, mapper=None, clause=None):
  class XRayFlaskSqlAlchemy (line 53) | class XRayFlaskSqlAlchemy(SQLAlchemy):
    method __init__ (line 54) | def __init__(self, app=None, use_native_unicode=True, session_options=...
    method create_session (line 59) | def create_session(self, options):

FILE: aws_xray_sdk/ext/httplib/patch.py
  function add_ignored (line 25) | def add_ignored(subclass=None, hostname=None, urls=None):
  function reset_ignored (line 32) | def reset_ignored():
  function _ignored_add_default (line 38) | def _ignored_add_default():
  function http_response_processor (line 47) | def http_response_processor(wrapped, instance, args, kwargs, return_value,
  function _xray_traced_http_getresponse (line 67) | def _xray_traced_http_getresponse(wrapped, instance, args, kwargs):
  function http_send_request_processor (line 80) | def http_send_request_processor(wrapped, instance, args, kwargs, return_...
  function _ignore_request (line 94) | def _ignore_request(instance, hostname, url):
  function _send_request (line 110) | def _send_request(wrapped, instance, args, kwargs):
  function http_read_processor (line 151) | def http_read_processor(wrapped, instance, args, kwargs, return_value,
  function _xray_traced_http_client_read (line 166) | def _xray_traced_http_client_read(wrapped, instance, args, kwargs):
  function patch (line 179) | def patch():
  function unpatch (line 207) | def unpatch():

FILE: aws_xray_sdk/ext/httpx/patch.py
  function patch (line 8) | def patch():
  class _InstrumentedClient (line 14) | class _InstrumentedClient(httpx.Client):
    method __init__ (line 15) | def __init__(self, *args, **kwargs):
  class _InstrumentedAsyncClient (line 22) | class _InstrumentedAsyncClient(httpx.AsyncClient):
    method __init__ (line 23) | def __init__(self, *args, **kwargs):
  class SyncInstrumentedTransport (line 30) | class SyncInstrumentedTransport(httpx.BaseTransport):
    method __init__ (line 31) | def __init__(self, transport: httpx.BaseTransport):
    method handle_request (line 34) | def handle_request(self, request: httpx.Request) -> httpx.Response:
  class AsyncInstrumentedTransport (line 52) | class AsyncInstrumentedTransport(httpx.AsyncBaseTransport):
    method __init__ (line 53) | def __init__(self, transport: httpx.AsyncBaseTransport):
    method handle_async_request (line 56) | async def handle_async_request(self, request: httpx.Request) -> httpx....

FILE: aws_xray_sdk/ext/mysql/patch.py
  function patch (line 13) | def patch():
  function _xray_traced_connect (line 26) | def _xray_traced_connect(wrapped, instance, args, kwargs):
  function sanitize_db_ver (line 43) | def sanitize_db_ver(raw):

FILE: aws_xray_sdk/ext/pg8000/patch.py
  function patch (line 9) | def patch():
  function _xray_traced_connect (line 18) | def _xray_traced_connect(wrapped, instance, args, kwargs):
  function unpatch (line 35) | def unpatch():

FILE: aws_xray_sdk/ext/psycopg/patch.py
  function patch (line 7) | def patch():
  function _xray_traced_connect (line 21) | def _xray_traced_connect(wrapped, instance, args, kwargs):

FILE: aws_xray_sdk/ext/psycopg2/patch.py
  function patch (line 9) | def patch():
  function _xray_traced_connect (line 33) | def _xray_traced_connect(wrapped, instance, args, kwargs):
  function _xray_register_type_fix (line 52) | def _xray_register_type_fix(wrapped, instance, args, kwargs):
  function _xray_register_default_jsonb_fix (line 61) | def _xray_register_default_jsonb_fix(wrapped, instance, args, kwargs):

FILE: aws_xray_sdk/ext/pymongo/patch.py
  class XrayCommandListener (line 6) | class XrayCommandListener(monitoring.CommandListener):
    method __init__ (line 17) | def __init__(self, record_full_documents):
    method started (line 21) | def started(self, event):
    method succeeded (line 35) | def succeeded(self, event):
    method failed (line 42) | def failed(self, event):
  function patch (line 50) | def patch(record_full_documents=False):

FILE: aws_xray_sdk/ext/pymysql/patch.py
  function patch (line 9) | def patch():
  function _xray_traced_connect (line 22) | def _xray_traced_connect(wrapped, instance, args, kwargs):
  function sanitize_db_ver (line 39) | def sanitize_db_ver(raw):
  function unpatch (line 47) | def unpatch():

FILE: aws_xray_sdk/ext/pynamodb/patch.py
  function patch (line 17) | def patch():
  function _xray_traced_pynamodb (line 40) | def _xray_traced_pynamodb(wrapped, instance, args, kwargs):
  function pynamodb_meta_processor (line 58) | def pynamodb_meta_processor(wrapped, instance, args, kwargs, return_value,

FILE: aws_xray_sdk/ext/requests/patch.py
  function patch (line 8) | def patch():
  function _xray_traced_requests (line 23) | def _xray_traced_requests(wrapped, instance, args, kwargs):
  function _inject_header (line 35) | def _inject_header(wrapped, instance, args, kwargs):
  function requests_processor (line 44) | def requests_processor(wrapped, instance, args, kwargs,

FILE: aws_xray_sdk/ext/sqlalchemy/query.py
  class XRaySession (line 8) | class XRaySession(Session):
  class XRayQuery (line 13) | class XRayQuery(Query):
  class XRaySessionMaker (line 18) | class XRaySessionMaker(sessionmaker):
    method __init__ (line 19) | def __init__(self, bind=None, class_=XRaySession, autoflush=True,

FILE: aws_xray_sdk/ext/sqlalchemy/util/decorators.py
  function decorate_all_functions (line 11) | def decorate_all_functions(function_decorator):
  function xray_on_call (line 27) | def xray_on_call(cls, func):
  function parse_bind (line 93) | def parse_bind(bind):

FILE: aws_xray_sdk/ext/sqlalchemy_core/patch.py
  function _sql_meta (line 14) | def _sql_meta(engine_instance, args):
  function _xray_traced_sqlalchemy_execute (line 57) | def _xray_traced_sqlalchemy_execute(wrapped, instance, args, kwargs):
  function _xray_traced_sqlalchemy_session (line 61) | def _xray_traced_sqlalchemy_session(wrapped, instance, args, kwargs):
  function _process_request (line 65) | def _process_request(wrapped, engine_instance, args, kwargs):
  function patch (line 86) | def patch():
  function unpatch (line 100) | def unpatch():

FILE: aws_xray_sdk/ext/sqlite3/patch.py
  function patch (line 7) | def patch():
  function _xray_traced_connect (line 16) | def _xray_traced_connect(wrapped, instance, args, kwargs):
  class XRayTracedSQLite (line 29) | class XRayTracedSQLite(XRayTracedConn):
    method execute (line 31) | def execute(self, *args, **kwargs):
    method executemany (line 34) | def executemany(self, *args, **kwargs):

FILE: aws_xray_sdk/ext/util.py
  function inject_trace_header (line 14) | def inject_trace_header(headers, entity):
  function calculate_sampling_decision (line 44) | def calculate_sampling_decision(trace_header, recorder, sampling_req):
  function construct_xray_header (line 62) | def construct_xray_header(headers):
  function calculate_segment_name (line 76) | def calculate_segment_name(host_name, recorder):
  function prepare_response_header (line 88) | def prepare_response_header(origin_header, segment):
  function to_snake_case (line 102) | def to_snake_case(name):
  function strip_url (line 112) | def strip_url(url):
  function get_hostname (line 121) | def get_hostname(url):
  function unwrap (line 131) | def unwrap(obj, attr):

FILE: aws_xray_sdk/sdk_config.py
  class SDKConfig (line 7) | class SDKConfig:
    method __get_enabled_from_env (line 35) | def __get_enabled_from_env(cls):
    method sdk_enabled (line 52) | def sdk_enabled(cls):
    method set_sdk_enabled (line 61) | def set_sdk_enabled(cls, value):

FILE: sample-apps/flask/application.py
  class User (line 20) | class User(db.Model):
  function callHTTP (line 29) | def callHTTP():
  function callAWSSDK (line 36) | def callAWSSDK():
  function callSQL (line 45) | def callSQL():
  function default (line 55) | def default():

FILE: tests/distributioncheck/test_sanity.py
  function test_create_segment (line 3) | def test_create_segment():

FILE: tests/ext/aiobotocore/test_aiobotocore.py
  function recorder (line 15) | def recorder(event_loop):
  function test_describe_table (line 27) | async def test_describe_table(event_loop, recorder):
  function test_s3_parameter_capture (line 50) | async def test_s3_parameter_capture(event_loop, recorder):
  function test_list_parameter_counting (line 75) | async def test_list_parameter_counting(event_loop, recorder):
  function test_map_parameter_grouping (line 108) | async def test_map_parameter_grouping(event_loop, recorder):
  function test_context_missing_not_swallow_return (line 136) | async def test_context_missing_not_swallow_return(event_loop, recorder):
  function test_context_missing_not_suppress_exception (line 152) | async def test_context_missing_not_suppress_exception(event_loop, record...

FILE: tests/ext/aiohttp/test_client.py
  function recorder (line 20) | def recorder(loop):
  function test_ok (line 30) | async def test_ok(loop, recorder):
  function test_ok_name (line 49) | async def test_ok_name(loop, recorder):
  function test_error (line 62) | async def test_error(loop, recorder):
  function test_throttle (line 81) | async def test_throttle(loop, recorder):
  function test_fault (line 101) | async def test_fault(loop, recorder):
  function test_invalid_url (line 120) | async def test_invalid_url(loop, recorder):
  function test_no_segment_raise (line 139) | async def test_no_segment_raise(loop, recorder):
  function test_no_segment_log_error (line 150) | async def test_no_segment_log_error(loop, recorder, caplog):
  function test_no_segment_ignore_error (line 165) | async def test_no_segment_ignore_error(loop, recorder, caplog):

FILE: tests/ext/aiohttp/test_middleware.py
  class CustomStubbedEmitter (line 22) | class CustomStubbedEmitter(UDPEmitter):
    method __init__ (line 27) | def __init__(self, daemon_address='127.0.0.1:2000'):
    method send_entity (line 31) | def send_entity(self, entity):
    method pop (line 34) | def pop(self):
  class ServerTest (line 41) | class ServerTest:
    method __init__ (line 47) | def __init__(self, loop):
    method handle_ok (line 50) | async def handle_ok(self, request: web.Request) -> web.Response:
    method handle_error (line 61) | async def handle_error(self, request: web.Request) -> web.Response:
    method handle_unauthorized (line 67) | async def handle_unauthorized(self, request: web.Request) -> web.Respo...
    method handle_exception (line 73) | async def handle_exception(self, request: web.Request) -> web.Response:
    method handle_delay (line 80) | async def handle_delay(self, request: web.Request) -> web.Response:
    method get_app (line 90) | def get_app(self) -> web.Application:
    method app (line 101) | def app(cls, loop=None) -> web.Application:
  function recorder (line 106) | def recorder(loop):
  function test_ok (line 123) | async def test_ok(aiohttp_client, loop, recorder):
  function test_ok_x_forwarded_for (line 147) | async def test_ok_x_forwarded_for(aiohttp_client, loop, recorder):
  function test_ok_content_length (line 165) | async def test_ok_content_length(aiohttp_client, loop, recorder):
  function test_error (line 182) | async def test_error(aiohttp_client, loop, recorder):
  function test_exception (line 207) | async def test_exception(aiohttp_client, loop, recorder):
  function test_unhauthorized (line 234) | async def test_unhauthorized(aiohttp_client, loop, recorder):
  function test_response_trace_header (line 259) | async def test_response_trace_header(aiohttp_client, loop, recorder):
  function test_concurrent (line 269) | async def test_concurrent(aiohttp_client, loop, recorder):
  function test_disabled_sdk (line 295) | async def test_disabled_sdk(aiohttp_client, loop, recorder):

FILE: tests/ext/botocore/test_botocore.py
  function construct_ctx (line 16) | def construct_ctx():
  function test_ddb_table_name (line 29) | def test_ddb_table_name():
  function test_s3_bucket_name_capture (line 53) | def test_s3_bucket_name_capture():
  function test_list_parameter_counting (line 77) | def test_list_parameter_counting():
  function test_map_parameter_grouping (line 107) | def test_map_parameter_grouping():
  function test_pass_through_on_context_missing (line 131) | def test_pass_through_on_context_missing():
  function test_sns_publish_parameters (line 155) | def test_sns_publish_parameters():

FILE: tests/ext/bottle/test_bottle.py
  function ok (line 20) | def ok():
  function error (line 28) | def error():
  function faulty_client (line 34) | def faulty_client():
  function faulty_server (line 44) | def faulty_server():
  function fault (line 49) | def fault():
  function template_ (line 54) | def template_():
  function view_ (line 60) | def view_(name='bottle'):
  function cleanup (line 75) | def cleanup():
  function test_ok (line 85) | def test_ok():
  function test_error (line 101) | def test_error():
  function test_custom_client_error (line 119) | def test_custom_client_error():
  function test_server_error (line 139) | def test_server_error():
  function test_fault (line 156) | def test_fault():
  function test_render_template (line 173) | def test_render_template():
  function test_render_view (line 187) | def test_render_view():
  function test_incoming_sampling_decision_respected (line 202) | def test_incoming_sampling_decision_respected():
  function test_trace_header_data_perservation (line 214) | def test_trace_header_data_perservation():
  function test_sampled_response_header (line 223) | def test_sampled_response_header():
  function test_disabled_sdk (line 233) | def test_disabled_sdk():
  function test_lambda_serverless (line 241) | def test_lambda_serverless():
  function test_lambda_default_ctx (line 285) | def test_lambda_default_ctx():

FILE: tests/ext/django/app/views.py
  class IndexView (line 8) | class IndexView(TemplateView):
  class TemplateBlockView (line 12) | class TemplateBlockView(TemplateView):
  function ok (line 16) | def ok(request):
  function fault (line 20) | def fault(request):
  function call_db (line 24) | def call_db(request):

FILE: tests/ext/django/test_db.py
  function setup (line 11) | def setup():
  function user_class (line 18) | def user_class(setup):
  function func_setup (line 37) | def func_setup(request, user_class):
  function _assert_query (line 52) | def _assert_query(sql_meta):
  function test_all (line 64) | def test_all(user_class):
  function test_filter (line 75) | def test_filter(user_class):

FILE: tests/ext/django/test_middleware.py
  class XRayTestCase (line 14) | class XRayTestCase(TestCase):
    method setUp (line 16) | def setUp(self):
    method tearDown (line 22) | def tearDown(self):
    method test_ok (line 25) | def test_ok(self):
    method test_error (line 37) | def test_error(self):
    method test_fault (line 49) | def test_fault(self):
    method test_db (line 68) | def test_db(self):
    method test_template (line 83) | def test_template(self):
    method test_template_block (line 94) | def test_template_block(self):
    method test_trace_header_data_perservation (line 105) | def test_trace_header_data_perservation(self):
    method test_response_header (line 113) | def test_response_header(self):
    method test_disabled_sdk (line 122) | def test_disabled_sdk(self):
    method test_lambda_serverless (line 129) | def test_lambda_serverless(self):
    method test_lambda_default_ctx (line 167) | def test_lambda_default_ctx(self):

FILE: tests/ext/django/test_settings.py
  class XRayConfigurationTestCase (line 13) | class XRayConfigurationTestCase(TestCase):
    method test_sampler_can_be_configured (line 14) | def test_sampler_can_be_configured(self):

FILE: tests/ext/flask/test_flask.py
  function ok (line 17) | def ok():
  function error (line 22) | def error():
  function fault (line 27) | def fault():
  function fault_no_exception (line 32) | def fault_no_exception():
  function template (line 37) | def template():
  function cleanup (line 57) | def cleanup():
  function test_ok (line 67) | def test_ok():
  function test_error (line 83) | def test_error():
  function test_fault (line 98) | def test_fault():
  function test_fault_no_exception (line 115) | def test_fault_no_exception():
  function test_render_template (line 127) | def test_render_template():
  function test_incoming_sampling_decision_respected (line 141) | def test_incoming_sampling_decision_respected():
  function test_trace_header_data_perservation (line 152) | def test_trace_header_data_perservation():
  function test_sampled_response_header (line 161) | def test_sampled_response_header():
  function test_disabled_sdk (line 171) | def test_disabled_sdk():
  function test_lambda_serverless (line 179) | def test_lambda_serverless():
  function test_lambda_default_ctx (line 221) | def test_lambda_default_ctx():

FILE: tests/ext/flask_sqlalchemy/test_query.py
  class User (line 15) | class User(db.Model):
  function session (line 30) | def session(request):
  function test_all (line 41) | def test_all(capsys, session):
  function test_add (line 52) | def test_add(capsys, session):

FILE: tests/ext/httplib/test_httplib.py
  function construct_ctx (line 15) | def construct_ctx():
  function _do_req (line 34) | def _do_req(url, method='GET', use_https=True):
  function test_ok (line 49) | def test_ok():
  function test_error (line 62) | def test_error():
  function test_throttle (line 76) | def test_throttle():
  function test_fault (line 91) | def test_fault():
  function test_invalid_url (line 105) | def test_invalid_url():
  function test_correct_identify_http (line 118) | def test_correct_identify_http():
  function test_correct_identify_https (line 129) | def test_correct_identify_https():
  function test_ignore_url (line 140) | def test_ignore_url():
  function test_ignore_hostname (line 149) | def test_ignore_hostname():
  function test_ignore_hostname_glob (line 158) | def test_ignore_hostname_glob():
  class CustomHttpsConnection (line 167) | class CustomHttpsConnection(httplib.HTTPSConnection):
  function test_ignore_subclass (line 171) | def test_ignore_subclass():
  function test_ignore_multiple_match (line 182) | def test_ignore_multiple_match():
  function test_ignore_multiple_no_match (line 193) | def test_ignore_multiple_no_match():

FILE: tests/ext/httpx/test_httpx.py
  function construct_ctx (line 17) | def construct_ctx():
  function test_ok (line 31) | def test_ok(use_client):
  function test_error (line 53) | def test_error(use_client):
  function test_throttle (line 75) | def test_throttle(use_client):
  function test_fault (line 98) | def test_fault(use_client):
  function test_nonexistent_domain (line 120) | def test_nonexistent_domain(use_client):
  function test_invalid_url (line 137) | def test_invalid_url(use_client):
  function test_name_uses_hostname (line 159) | def test_name_uses_hostname(use_client):
  function test_strip_http_url (line 201) | def test_strip_http_url(use_client):

FILE: tests/ext/httpx/test_httpx_async.py
  function construct_ctx (line 17) | def construct_ctx():
  function test_ok_async (line 31) | async def test_ok_async():
  function test_error_async (line 50) | async def test_error_async():
  function test_throttle_async (line 69) | async def test_throttle_async():
  function test_fault_async (line 89) | async def test_fault_async():
  function test_nonexistent_domain_async (line 108) | async def test_nonexistent_domain_async():
  function test_invalid_url_async (line 122) | async def test_invalid_url_async():
  function test_name_uses_hostname_async (line 141) | async def test_name_uses_hostname_async():
  function test_strip_http_url_async (line 176) | async def test_strip_http_url_async():

FILE: tests/ext/pg8000/test_pg8000.py
  function patch_module (line 13) | def patch_module():
  function construct_ctx (line 20) | def construct_ctx():
  function test_execute_dsn_kwargs (line 33) | def test_execute_dsn_kwargs():
  function test_execute_bad_query (line 53) | def test_execute_bad_query():

FILE: tests/ext/psycopg/test_psycopg.py
  function construct_ctx (line 16) | def construct_ctx():
  function test_execute_dsn_kwargs (line 29) | def test_execute_dsn_kwargs():
  function test_execute_dsn_string (line 51) | def test_execute_dsn_string():
  function test_execute_in_pool (line 73) | def test_execute_in_pool():
  function test_execute_bad_query (line 98) | def test_execute_bad_query():
  function test_query_as_string (line 125) | def test_query_as_string():

FILE: tests/ext/psycopg2/test_psycopg2.py
  function construct_ctx (line 17) | def construct_ctx():
  function test_execute_dsn_kwargs (line 30) | def test_execute_dsn_kwargs():
  function test_execute_dsn_kwargs_alt_dbname (line 52) | def test_execute_dsn_kwargs_alt_dbname():
  function test_execute_dsn_string (line 78) | def test_execute_dsn_string():
  function test_execute_in_pool (line 100) | def test_execute_in_pool():
  function test_execute_bad_query (line 123) | def test_execute_bad_query():
  function test_register_extensions (line 151) | def test_register_extensions():
  function test_query_as_string (line 164) | def test_query_as_string():
  function test_register_default_jsonb (line 178) | def test_register_default_jsonb():

FILE: tests/ext/pymysql/test_pymysql.py
  function patch_module (line 17) | def patch_module():
  function construct_ctx (line 24) | def construct_ctx():
  function test_execute_dsn_kwargs (line 37) | def test_execute_dsn_kwargs():
  function test_execute_bad_query (line 56) | def test_execute_bad_query():

FILE: tests/ext/pynamodb/test_pynamodb.py
  function construct_ctx (line 18) | def construct_ctx():
  function test_exception (line 31) | def test_exception():
  function test_empty_response (line 57) | def test_empty_response():
  function test_only_dynamodb_calls_are_traced (line 80) | def test_only_dynamodb_calls_are_traced():

FILE: tests/ext/requests/test_requests.py
  function construct_ctx (line 17) | def construct_ctx():
  function test_ok (line 30) | def test_ok():
  function test_error (line 44) | def test_error():
  function test_throttle (line 58) | def test_throttle():
  function test_fault (line 73) | def test_fault():
  function test_nonexistent_domain (line 87) | def test_nonexistent_domain():
  function test_invalid_url (line 100) | def test_invalid_url():
  function test_name_uses_hostname (line 118) | def test_name_uses_hostname():
  function test_strip_http_url (line 148) | def test_strip_http_url():

FILE: tests/ext/sqlalchemy/test_query.py
  class User (line 13) | class User(Base):
  function engine (line 23) | def engine():
  function session (line 28) | def session(engine):
  function connection (line 43) | def connection(engine):
  function test_all (line 57) | def test_all(capsys, session):
  function test_supports_connection (line 68) | def test_supports_connection(capsys, connection):
  function test_add (line 76) | def test_add(capsys, session):
  function test_filter_first (line 87) | def test_filter_first(capsys, session):

FILE: tests/ext/sqlalchemy_core/test_base.py
  class User (line 12) | class User(Base):
  function db_url (line 22) | def db_url():
  function engine (line 27) | def engine(db_url):
  function connection (line 47) | def connection(engine):
  function session (line 52) | def session(engine):

FILE: tests/ext/sqlalchemy_core/test_dburl.py
  function construct_ctx (line 18) | def construct_ctx():
  function test_db_url_with_special_char (line 31) | def test_db_url_with_special_char():

FILE: tests/ext/sqlalchemy_core/test_postgres.py
  function postgres_db (line 15) | def postgres_db():
  function db_url (line 21) | def db_url(postgres_db):
  function sanitized_db_url (line 26) | def sanitized_db_url(postgres_db):
  function test_all (line 36) | def test_all(session, sanitized_db_url):
  function test_insert_on_conflict_renders (line 47) | def test_insert_on_conflict_renders(connection):

FILE: tests/ext/sqlalchemy_core/test_sqlalchemy_core.py
  function test_all (line 5) | def test_all(session):
  function test_filter_first (line 16) | def test_filter_first(session):
  function test_connection_add (line 27) | def test_connection_add(connection):
  function test_connection_query (line 38) | def test_connection_query(connection):

FILE: tests/ext/sqlalchemy_core/test_sqlalchemy_core_2.py
  function test_orm_style_select_execution (line 7) | def test_orm_style_select_execution(session):

FILE: tests/ext/sqlite3/test_sqlite3.py
  function db (line 11) | def db():
  function construct_ctx (line 17) | def construct_ctx():
  function test_execute (line 30) | def test_execute(db):
  function test_invalid_syntax (line 42) | def test_invalid_syntax(db):

FILE: tests/mock_module/__init__.py
  function mock_init (line 1) | def mock_init():

FILE: tests/mock_module/mock_file.py
  function mock_func (line 1) | def mock_func():

FILE: tests/mock_module/mock_submodule/__init__.py
  function mock_subinit (line 1) | def mock_subinit():

FILE: tests/mock_module/mock_submodule/mock_subfile.py
  function mock_subfunc (line 4) | def mock_subfunc():
  function mock_no_doublepatch (line 9) | def mock_no_doublepatch():
  class MockClass (line 13) | class MockClass:
    method __init__ (line 14) | def __init__(self):
    method mock_method (line 17) | def mock_method(self):
    method mock_classmethod (line 21) | def mock_classmethod(cls):
    method mock_staticmethod (line 26) | def mock_staticmethod():
  class MockSubclass (line 30) | class MockSubclass(MockClass):
    method __init__ (line 31) | def __init__(self):
    method mock_submethod (line 34) | def mock_submethod(self):

FILE: tests/test_async_local_storage.py
  function test_localstorage_isolation (line 8) | def test_localstorage_isolation(event_loop):

FILE: tests/test_async_recorder.py
  function async_method2 (line 13) | async def async_method2():
  function async_method (line 18) | async def async_method():
  function test_capture (line 22) | async def test_capture(event_loop):
  function test_concurrent_calls (line 49) | async def test_concurrent_calls(event_loop):
  function test_async_context_managers (line 74) | async def test_async_context_managers(event_loop):

FILE: tests/test_daemon_config.py
  function test_default_config (line 11) | def test_default_config():
  function test_single_address (line 20) | def test_single_address():
  function test_set_tcp_udp_separately (line 30) | def test_set_tcp_udp_separately():
  function test_invalid_address (line 48) | def test_invalid_address():

FILE: tests/test_dummy_entites.py
  function test_not_sampled (line 5) | def test_not_sampled():
  function test_no_ops (line 13) | def test_no_ops():
  function test_structure_intact (line 42) | def test_structure_intact():
  function test_invalid_entity_name (line 58) | def test_invalid_entity_name():
  function test_dummy_segment_trace_id (line 66) | def test_dummy_segment_trace_id():

FILE: tests/test_facade_segment.py
  function test_not_ready (line 9) | def test_not_ready():
  function test_initializing (line 16) | def test_initializing():
  function test_unsupported_operations (line 25) | def test_unsupported_operations():
  function test_structure_intact (line 48) | def test_structure_intact():
  function test_adding_unsampled_subsegment (line 59) | def test_adding_unsampled_subsegment():

FILE: tests/test_lambda_context.py
  function setup (line 20) | def setup():
  function test_facade_segment_generation (line 25) | def test_facade_segment_generation():
  function test_put_subsegment (line 34) | def test_put_subsegment():
  function test_disable (line 58) | def test_disable():
  function test_non_initialized (line 70) | def test_non_initialized():
  function test_lambda_passthrough (line 89) | def test_lambda_passthrough():
  function test_set_trace_entity (line 114) | def test_set_trace_entity():

FILE: tests/test_local_sampling.py
  function test_should_trace (line 35) | def test_should_trace():
  function test_missing_version_num (line 43) | def test_missing_version_num():
  function test_default_matching (line 51) | def test_default_matching():
  function test_path_matching (line 56) | def test_path_matching():
  function test_negative_rate (line 66) | def test_negative_rate():
  function test_negative_fixed_target (line 74) | def test_negative_fixed_target():
  function test_invalid_default (line 82) | def test_invalid_default():
  function test_incomplete_path_rule (line 88) | def test_incomplete_path_rule():

FILE: tests/test_local_sampling_benchmark.py
  function test_pkgutil_static_read (line 6) | def test_pkgutil_static_read(benchmark):
  function test_pathlib_static_read (line 12) | def test_pathlib_static_read(benchmark):

FILE: tests/test_patcher.py
  function construct_ctx (line 30) | def construct_ctx():
  function _call_all_mock_functions (line 61) | def _call_all_mock_functions():
  function test_incorrect_import_fails (line 81) | def test_incorrect_import_fails(modules):
  function test_external_file (line 87) | def test_external_file():
  function test_external_module (line 101) | def test_external_module():
  function test_external_submodules_full (line 121) | def test_external_submodules_full():
  function test_external_submodules_ignores_file (line 143) | def test_external_submodules_ignores_file():
  function test_external_submodules_ignores_module (line 164) | def test_external_submodules_ignores_module():
  function test_disable_sdk_disables_patching (line 179) | def test_disable_sdk_disables_patching():

FILE: tests/test_plugins.py
  function test_runtime_context_available (line 12) | def test_runtime_context_available():
  function test_ec2_plugin_imdsv2_success (line 21) | def test_ec2_plugin_imdsv2_success(mock_do_request):
  function test_ec2_plugin_v2_fail_v1_success (line 38) | def test_ec2_plugin_v2_fail_v1_success(mock_do_request):
  function test_ec2_plugin_v2_fail_v1_fail (line 55) | def test_ec2_plugin_v2_fail_v1_fail(mock_do_request):

FILE: tests/test_recorder.py
  function construct_ctx (line 22) | def construct_ctx(monkeypatch):
  function test_default_runtime_context (line 34) | def test_default_runtime_context():
  function test_subsegment_parenting (line 45) | def test_subsegment_parenting():
  function test_subsegments_streaming (line 68) | def test_subsegments_streaming():
  function test_subsegment_streaming_set_zero (line 81) | def test_subsegment_streaming_set_zero():
  function test_put_annotation_metadata (line 91) | def test_put_annotation_metadata():
  function test_default_pass_through_with_missing_context (line 103) | def test_default_pass_through_with_missing_context():
  function test_raise_runtime_error_with_missing_context (line 112) | def test_raise_runtime_error_with_missing_context():
  function test_capture_not_suppress_exception (line 120) | def test_capture_not_suppress_exception():
  function test_capture_not_swallow_return (line 132) | def test_capture_not_swallow_return():
  function test_first_begin_segment_sampled (line 145) | def test_first_begin_segment_sampled():
  function test_unsampled_subsegment_of_sampled_parent (line 152) | def test_unsampled_subsegment_of_sampled_parent():
  function test_begin_subsegment_unsampled (line 161) | def test_begin_subsegment_unsampled():
  function test_in_segment_closing (line 171) | def test_in_segment_closing():
  function test_in_segment_exception (line 192) | def test_in_segment_exception():
  function test_default_enabled (line 215) | def test_default_enabled():
  function test_disable_is_dummy (line 223) | def test_disable_is_dummy():
  function test_unsampled_subsegment_is_dummy (line 230) | def test_unsampled_subsegment_is_dummy():
  function test_subsegment_respects_parent_sampling_decision (line 237) | def test_subsegment_respects_parent_sampling_decision():
  function test_disabled_empty_context_current_calls (line 248) | def test_disabled_empty_context_current_calls():
  function test_disabled_out_of_order_begins (line 254) | def test_disabled_out_of_order_begins():
  function test_disabled_put_methods (line 264) | def test_disabled_put_methods():
  function test_disabled_ends (line 272) | def test_disabled_ends():
  function test_disabled_begin_subsegment (line 283) | def test_disabled_begin_subsegment():
  function test_disabled_force_sampling (line 290) | def test_disabled_force_sampling():
  function test_disabled_get_context_entity (line 300) | def test_disabled_get_context_entity():
  function test_max_stack_trace_zero (line 306) | def test_max_stack_trace_zero():
  class CustomSampler (line 329) | class CustomSampler(DefaultSampler):
    method start (line 330) | def start(self):
    method should_trace (line 333) | def should_trace(self, sampling_req=None):
  function test_begin_segment_matches_sampling_rule_on_name (line 359) | def test_begin_segment_matches_sampling_rule_on_name():

FILE: tests/test_sampling_rule_cache.py
  function reset_rules (line 25) | def reset_rules():
  function test_rules_sorting (line 36) | def test_rules_sorting():
  function test_evict_deleted_rules (line 48) | def test_evict_deleted_rules():
  function test_rule_matching (line 58) | def test_rule_matching():
  function test_preserving_sampling_statistics (line 90) | def test_preserving_sampling_statistics():
  function test_correct_target_mapping (line 110) | def test_correct_target_mapping():
  function test_expired_cache (line 124) | def test_expired_cache():

FILE: tests/test_sdk_config.py
  function cleanup (line 10) | def cleanup():
  function test_enable_key (line 22) | def test_enable_key():
  function test_default_enabled (line 26) | def test_default_enabled():
  function test_env_var_precedence (line 30) | def test_env_var_precedence():
  function test_env_enable_case (line 49) | def test_env_enable_case():
  function test_invalid_env_string (line 84) | def test_invalid_env_string():

FILE: tests/test_serialize_entities.py
  function test_serialize_segment (line 14) | def test_serialize_segment():
  function test_serialize_segment_with_aws (line 32) | def test_serialize_segment_with_aws():
  function test_serialize_segment_with_services (line 66) | def test_serialize_segment_with_services():
  function test_serialize_segment_with_annotation (line 96) | def test_serialize_segment_with_annotation():
  function test_serialize_segment_with_metadata (line 120) | def test_serialize_segment_with_metadata():
  function test_serialize_segment_with_http (line 217) | def test_serialize_segment_with_http():
  function test_serialize_segment_with_exception (line 257) | def test_serialize_segment_with_exception():
  function test_serialize_subsegment (line 363) | def test_serialize_subsegment():
  function test_serialize_subsegment_with_http (line 386) | def test_serialize_subsegment_with_http():
  function test_serialize_subsegment_with_sql (line 425) | def test_serialize_subsegment_with_sql():
  function test_serialize_subsegment_with_aws (line 469) | def test_serialize_subsegment_with_aws():
  function test_serialize_with_ast_metadata (line 515) | def test_serialize_with_ast_metadata():

FILE: tests/test_sqs_message_helper.py
  function test_return_true_when_sampling_1 (line 61) | def test_return_true_when_sampling_1():
  function test_return_false_when_sampling_0 (line 64) | def test_return_false_when_sampling_0():
  function test_return_false_with_no_sampling_flag (line 67) | def test_return_false_with_no_sampling_flag():

FILE: tests/test_throwable.py
  function test_message_and_type (line 4) | def test_message_and_type():
  function test_stack_trace_parsing (line 13) | def test_stack_trace_parsing():

FILE: tests/test_trace_entities.py
  function test_unicode_entity_name (line 18) | def test_unicode_entity_name():
  function test_segment_user (line 29) | def test_segment_user():
  function test_put_http_meta (line 37) | def test_put_http_meta():
  function test_put_metadata (line 51) | def test_put_metadata():
  function test_put_annotation (line 71) | def test_put_annotation():
  function test_reference_counting (line 96) | def test_reference_counting():
  function test_flags_on_status_code (line 121) | def test_flags_on_status_code():
  function test_mutate_closed_entity (line 137) | def test_mutate_closed_entity():
  function test_no_rule_name_pollution (line 155) | def test_no_rule_name_pollution():
  function test_no_empty_properties (line 165) | def test_no_empty_properties():
  function test_required_properties (line 179) | def test_required_properties():
  function test_missing_segment_name (line 191) | def test_missing_segment_name():
  function test_missing_parent_segment (line 197) | def test_missing_parent_segment():
  function test_add_exception (line 203) | def test_add_exception():
  function test_add_exception_referencing (line 221) | def test_add_exception_referencing():
  function test_add_exception_cause_resetting (line 239) | def test_add_exception_cause_resetting():
  function test_add_exception_appending_exceptions (line 256) | def test_add_exception_appending_exceptions():
  function test_adding_subsegments_with_recorder (line 266) | def test_adding_subsegments_with_recorder():

FILE: tests/test_trace_header.py
  function test_no_sample (line 8) | def test_no_sample():
  function test_no_parent (line 16) | def test_no_parent():
  function test_from_str (line 22) | def test_from_str():
  function test_arbitrary_fields (line 45) | def test_arbitrary_fields():
  function test_invalid_str (line 54) | def test_invalid_str():

FILE: tests/test_traceid.py
  function cleanup (line 8) | def cleanup():
  function test_id_format (line 19) | def test_id_format():
  function test_id_generation_default_sampling_false (line 29) | def test_id_generation_default_sampling_false():
  function test_id_generation_default_sampling_true (line 46) | def test_id_generation_default_sampling_true():
  function test_id_generation_noop_true (line 63) | def test_id_generation_noop_true():
  function test_id_generation_noop_false (line 81) | def test_id_generation_noop_false():

FILE: tests/test_utils.py
  function test_to_snake_case (line 12) | def test_to_snake_case():
  function test_get_hostname (line 26) | def test_get_hostname():
  function test_strip_url (line 49) | def test_strip_url():
  function test_inject_trace_header_unsampled (line 63) | def test_inject_trace_header_unsampled():
  function test_inject_trace_header_respects_parent_subsegment (line 74) | def test_inject_trace_header_respects_parent_subsegment():
  function test_inject_trace_header_sampled (line 86) | def test_inject_trace_header_sampled():

FILE: tests/test_wildcard_match.py
  function test_match_exact_positive (line 4) | def test_match_exact_positive():
  function test_match_exact_negative (line 10) | def test_match_exact_negative():
  function test_single_wildcard_positive (line 16) | def test_single_wildcard_positive():
  function test_single_wildcard_negative (line 22) | def test_single_wildcard_negative():
  function test_multiple_wildcard_positive (line 28) | def test_multiple_wildcard_positive():
  function test_multiple_wildcard_negative (line 34) | def test_multiple_wildcard_negative():
  function test_glob_positive_zero_or_more (line 40) | def test_glob_positive_zero_or_more():
  function test_glob_negative_zero_or_more (line 46) | def test_glob_negative_zero_or_more():
  function test_glob_negative (line 52) | def test_glob_negative():
  function test_glob_and_single_positive (line 58) | def test_glob_and_single_positive():
  function test_glob_and_single_negative (line 64) | def test_glob_and_single_negative():
  function test_pure_wildcard (line 70) | def test_pure_wildcard():
  function test_exact_match (line 76) | def test_exact_match():
  function test_misc (line 82) | def test_misc():
  function test_case_insensitivity (line 105) | def test_case_insensitivity():
  function test_no_globs (line 126) | def test_no_globs():
  function test_edge_case_globs (line 130) | def test_edge_case_globs():
  function test_multi_globs (line 149) | def test_multi_globs():

FILE: tests/util.py
  class CircularReferenceClass (line 10) | class CircularReferenceClass:
    method __init__ (line 12) | def __init__(self, name):
  class StubbedEmitter (line 17) | class StubbedEmitter(UDPEmitter):
    method __init__ (line 19) | def __init__(self, daemon_address='127.0.0.1:2000'):
    method send_entity (line 23) | def send_entity(self, entity):
    method pop (line 26) | def pop(self):
  class StubbedSampler (line 36) | class StubbedSampler(DefaultSampler):
    method start (line 38) | def start(self):
  function get_new_stubbed_recorder (line 42) | def get_new_stubbed_recorder():
  function entity_to_dict (line 53) | def entity_to_dict(trace_entity):
  function _search_entity (line 59) | def _search_entity(entity, name):
  function find_subsegment (line 75) | def find_subsegment(segment, name):
  function find_subsegment_by_annotation (line 85) | def find_subsegment_by_annotation(segment, key, value):
  function _search_entity_by_annotation (line 95) | def _search_entity_by_annotation(entity, key, value):
  function test_metadata_to_dict_self_reference (line 112) | def test_metadata_to_dict_self_reference():