diff --git a/tests/conftest.py b/tests/conftest.py index 0b29ae43de0..ad3dd62b68a 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -184,7 +184,9 @@ def tracer(use_global_tracer): if use_global_tracer: return ddtrace.tracer else: - return DummyTracer() + t = DummyTracer() + yield t + t.shutdown() @pytest.fixture diff --git a/tests/tracer/test_gitmetadata.py b/tests/tracer/test_gitmetadata.py index 7513f5d1929..e7504b8e817 100644 --- a/tests/tracer/test_gitmetadata.py +++ b/tests/tracer/test_gitmetadata.py @@ -10,7 +10,6 @@ import pytest from tests.subprocesstest import run_in_subprocess -from tests.utils import DummyTracer from tests.utils import TracerTestCase @@ -42,9 +41,7 @@ class GitMetadataTestCase(TracerTestCase): DD_MAIN_PACKAGE="mypackage", ) ) - def test_gitmetadata_from_package(self): - tracer = DummyTracer() - + def test_gitmetadata_from_package(self, tracer): with tracer.trace("span") as s: pass @@ -57,9 +54,7 @@ def test_gitmetadata_from_package(self): DD_TAGS="git.commit.sha:12345,git.repository_url:github.com/user/tag_repo", ) ) - def test_gitmetadata_from_DD_TAGS(self): - tracer = DummyTracer() - + def test_gitmetadata_from_DD_TAGS(self, tracer): with tracer.trace("span") as s: pass @@ -78,9 +73,7 @@ def test_gitmetadata_from_DD_TAGS(self): DD_MAIN_PACKAGE="mypackage", ) ) - def test_gitmetadata_from_ENV(self): - tracer = DummyTracer() - + def test_gitmetadata_from_ENV(self, tracer): with tracer.trace("span") as s: pass @@ -102,9 +95,7 @@ def test_gitmetadata_from_ENV(self): DD_TRACE_GIT_METADATA_ENABLED="false", ) ) - def test_gitmetadata_disabled(self): - tracer = DummyTracer() - + def test_gitmetadata_disabled(self, tracer): with tracer.trace("span") as s: pass @@ -121,9 +112,7 @@ def test_gitmetadata_disabled(self): DD_MAIN_PACKAGE="pytest", ) ) - def test_gitmetadata_package_without_metadata(self): - tracer = DummyTracer() - + def test_gitmetadata_package_without_metadata(self, tracer): with tracer.trace("span") as s: pass @@ -141,9 +130,7 @@ def test_gitmetadata_package_without_metadata(self): DD_MAIN_PACKAGE="mypackage", ) ) - def test_gitmetadata_from_env_filtering_https(self): - tracer = DummyTracer() - + def test_gitmetadata_from_env_filtering_https(self, tracer): with tracer.trace("span") as s: pass @@ -161,9 +148,7 @@ def test_gitmetadata_from_env_filtering_https(self): DD_TAGS="git.commit.sha:12345,git.repository_url:https://username:password@github.com/user/tag_repo.git", ) ) - def test_gitmetadata_from_ddtags_filtering_https(self): - tracer = DummyTracer() - + def test_gitmetadata_from_ddtags_filtering_https(self, tracer): with tracer.trace("span") as s: pass @@ -182,9 +167,7 @@ def test_gitmetadata_from_ddtags_filtering_https(self): DD_MAIN_PACKAGE="mypackage", ) ) - def test_gitmetadata_from_env_filtering_ssh(self): - tracer = DummyTracer() - + def test_gitmetadata_from_env_filtering_ssh(self, tracer): with tracer.trace("span") as s: pass @@ -202,9 +185,7 @@ def test_gitmetadata_from_env_filtering_ssh(self): DD_TAGS="git.commit.sha:12345,git.repository_url:ssh://username@github.com/user/tag_repo.git", ) ) - def test_gitmetadata_from_ddtags_filtering_ssh(self): - tracer = DummyTracer() - + def test_gitmetadata_from_ddtags_filtering_ssh(self, tracer): with tracer.trace("span") as s: pass diff --git a/tests/tracer/test_global_config.py b/tests/tracer/test_global_config.py index 0d60f2319e7..c685bae123d 100644 --- a/tests/tracer/test_global_config.py +++ b/tests/tracer/test_global_config.py @@ -7,7 +7,6 @@ from ddtrace.internal.settings._config import Config from ddtrace.internal.settings.integration import IntegrationConfig -from ..utils import DummyTracer from ..utils import override_env @@ -17,7 +16,6 @@ class GlobalConfigTestCase(TestCase): def setUp(self): self.config = Config() self.config.web = IntegrationConfig(self.config, "web") - self.tracer = DummyTracer() def test_registration(self): # ensure an integration can register a new list of settings @@ -112,7 +110,7 @@ def test_settings_merge_deep(self): assert self.config.requests["a"]["b"]["c"] is True assert self.config.requests["a"]["b"]["d"] is True - def test_settings_hook(self): + def test_settings_hook(self, tracer): """ When calling `Hooks.emit()` When there is a hook registered @@ -125,7 +123,7 @@ def on_web_request(span): span.set_tag("web.request", "/") # Create our span - with self.tracer.start_span("web.request") as span: + with tracer.start_span("web.request") as span: assert "web.request" not in span.get_tags() # Emit the span @@ -134,7 +132,7 @@ def on_web_request(span): # Assert we updated the span as expected assert span.get_tag("web.request") == "/" - def test_settings_hook_args(self): + def test_settings_hook_args(self, tracer): """ When calling `Hooks.emit()` with arguments When there is a hook registered @@ -148,7 +146,7 @@ def on_web_request(span, request, response): span.set_tag("web.response", response) # Create our span - with self.tracer.start_span("web.request") as span: + with tracer.start_span("web.request") as span: assert "web.request" not in span.get_tags() # Emit the span @@ -159,7 +157,7 @@ def on_web_request(span, request, response): assert span.get_tag("web.request") == "request" assert span.get_tag("web.response") == "response" - def test_settings_hook_args_failure(self): + def test_settings_hook_args_failure(self, tracer): """ When calling `Hooks.emit()` with arguments When there is a hook registered that is missing parameters @@ -173,7 +171,7 @@ def on_web_request(span, request): span.set_tag("web.request", request) # Create our span - with self.tracer.start_span("web.request") as span: + with tracer.start_span("web.request") as span: assert "web.request" not in span.get_tags() # Emit the span @@ -183,7 +181,7 @@ def on_web_request(span, request): # Assert we did not update the span assert "web.request" not in span.get_tags() - def test_settings_multiple_hooks(self): + def test_settings_multiple_hooks(self, tracer): """ When calling `Hooks.emit()` When there are multiple hooks registered @@ -204,7 +202,7 @@ def on_web_request3(span): span.set_tag("web.method", "GET") # Create our span - with self.tracer.start_span("web.request") as span: + with tracer.start_span("web.request") as span: assert "web.request" not in span.get_tags() assert "web.status" not in span.get_metrics() assert "web.method" not in span.get_tags() @@ -217,7 +215,7 @@ def on_web_request3(span): assert span.get_metric("web.status") == 200 assert span.get_tag("web.method") == "GET" - def test_settings_hook_failure(self): + def test_settings_hook_failure(self, tracer): """ When calling `Hooks.emit()` When the hook raises an exception @@ -228,20 +226,20 @@ def test_settings_hook_failure(self): self.config.web.hooks.register("request")(on_web_request) # Create our span - with self.tracer.start_span("web.request") as span: + with tracer.start_span("web.request") as span: # Emit the span # DEV: This is the test, to ensure no exceptions are raised self.config.web.hooks.emit("request", span) on_web_request.assert_called() - def test_settings_no_hook(self): + def test_settings_no_hook(self, tracer): """ When calling `Hooks.emit()` When no hook is registered we do not raise an exception """ # Create our span - with self.tracer.start_span("web.request") as span: + with tracer.start_span("web.request") as span: # Emit the span # DEV: This is the test, to ensure no exceptions are raised self.config.web.hooks.emit("request", span) diff --git a/tests/tracer/test_processors.py b/tests/tracer/test_processors.py index e6b96dc0f41..b54dc384216 100644 --- a/tests/tracer/test_processors.py +++ b/tests/tracer/test_processors.py @@ -28,7 +28,6 @@ from ddtrace.internal.writer import NativeWriter from ddtrace.trace import Context from ddtrace.trace import Span -from tests.utils import DummyTracer from tests.utils import DummyWriter from tests.utils import override_global_config @@ -398,11 +397,9 @@ def test_trace_top_level_span_processor_partial_flushing(): assert parent.get_metric("_dd.top_level") == 1 -def test_trace_top_level_span_processor_same_service_name(): +def test_trace_top_level_span_processor_same_service_name(tracer): """Parent span and child span have the same service name""" - tracer = DummyTracer() - with tracer.trace("parent", service="top_level_test") as parent: with tracer.trace("child") as child: pass @@ -411,11 +408,9 @@ def test_trace_top_level_span_processor_same_service_name(): assert "_dd.top_level" not in child.get_metrics() -def test_trace_top_level_span_processor_different_service_name(): +def test_trace_top_level_span_processor_different_service_name(tracer): """Parent span and child span have the different service names""" - tracer = DummyTracer() - with tracer.trace("parent", service="top_level_test_service") as parent: with tracer.trace("child", service="top_level_test_service2") as child: pass @@ -424,11 +419,9 @@ def test_trace_top_level_span_processor_different_service_name(): assert child.get_metric("_dd.top_level") == 1 -def test_trace_top_level_span_processor_orphan_span(): +def test_trace_top_level_span_processor_orphan_span(tracer): """Trace chuck does not contain parent span""" - tracer = DummyTracer() - with tracer.trace("parent") as parent: pass @@ -514,9 +507,8 @@ def test_span_creation_metrics(): ) -def test_changing_tracer_sampler_changes_tracesamplingprocessor_sampler(): +def test_changing_tracer_sampler_changes_tracesamplingprocessor_sampler(tracer): """Changing the tracer sampler should change the sampling processor's sampler""" - tracer = DummyTracer() # get processor sampling_processor = tracer._span_aggregator.sampling_processor assert sampling_processor.sampler is tracer._sampler @@ -527,13 +519,12 @@ def test_changing_tracer_sampler_changes_tracesamplingprocessor_sampler(): assert sampling_processor.sampler is new_sampler -def test_single_span_sampling_processor(): +def test_single_span_sampling_processor(tracer): """Test that single span sampling tags are applied to spans that should get sampled""" rule_1 = SpanSamplingRule(service="test_service", name="test_name", sample_rate=1.0, max_per_second=-1) rules = [rule_1] sampling_processor = TraceSamplingProcessor(False, rules, False) sampling_processor.sampler.rules = [TraceSamplingRule(sample_rate=0.0)] - tracer = DummyTracer() switch_out_trace_sampling_processor(tracer, sampling_processor) span = traced_function(tracer) @@ -541,7 +532,7 @@ def test_single_span_sampling_processor(): assert_span_sampling_decision_tags(span) -def test_single_span_sampling_processor_match_second_rule(): +def test_single_span_sampling_processor_match_second_rule(tracer): """Test that single span sampling rule is applied if the first rule does not match, but a later one does""" rule_1 = SpanSamplingRule(service="test_service", name="test_name", sample_rate=1.0, max_per_second=-1) @@ -549,7 +540,6 @@ def test_single_span_sampling_processor_match_second_rule(): rules = [rule_1, rule_2] processor = TraceSamplingProcessor(False, rules, False) processor.sampler.rules = [TraceSamplingRule(sample_rate=0.0)] - tracer = DummyTracer() switch_out_trace_sampling_processor(tracer, processor) span = traced_function(tracer, name="test_name2", service="test_service2") @@ -557,7 +547,7 @@ def test_single_span_sampling_processor_match_second_rule(): assert_span_sampling_decision_tags(span) -def test_single_span_sampling_processor_rule_order_drop(): +def test_single_span_sampling_processor_rule_order_drop(tracer): """Test that single span sampling rules are applied in an order and will only be applied if earlier rules have not been """ @@ -567,7 +557,6 @@ def test_single_span_sampling_processor_rule_order_drop(): rules = [rule_1, rule_2] processor = TraceSamplingProcessor(False, rules, False) processor.sampler.rules = [TraceSamplingRule(sample_rate=0.0)] - tracer = DummyTracer() switch_out_trace_sampling_processor(tracer, processor) span = traced_function(tracer) @@ -575,7 +564,7 @@ def test_single_span_sampling_processor_rule_order_drop(): assert_span_sampling_decision_tags(span, sample_rate=None, mechanism=None, limit=None) -def test_single_span_sampling_processor_rule_order_keep(): +def test_single_span_sampling_processor_rule_order_keep(tracer): """Test that single span sampling rules are applied in an order and will not be applied if an earlier rule has been """ @@ -585,7 +574,6 @@ def test_single_span_sampling_processor_rule_order_keep(): rules = [rule_1, rule_2] processor = TraceSamplingProcessor(False, rules, False) processor.sampler.rules = [TraceSamplingRule(sample_rate=0.0)] - tracer = DummyTracer() switch_out_trace_sampling_processor(tracer, processor) span = traced_function(tracer) @@ -611,7 +599,7 @@ def test_single_span_sampling_processor_rule_order_keep(): ], ) def test_single_span_sampling_processor_w_tracer_sampling( - span_sample_rate_rule, expected_span_sample_rate_tag, mechanism, trace_sampling_priority + tracer, span_sample_rate_rule, expected_span_sample_rate_tag, mechanism, trace_sampling_priority ): """Test how the single span sampler interacts with the trace sampler""" @@ -621,7 +609,6 @@ def test_single_span_sampling_processor_w_tracer_sampling( rules = [rule_1] processor = TraceSamplingProcessor(False, rules, False) processor.sampler.rules = [TraceSamplingRule(sample_rate=0.0)] - tracer = DummyTracer() switch_out_trace_sampling_processor(tracer, processor) span = traced_function(tracer, trace_sampling_priority=trace_sampling_priority) @@ -634,7 +621,7 @@ def test_single_span_sampling_processor_w_tracer_sampling( ) -def test_single_span_sampling_processor_w_tracer_sampling_after_processing(): +def test_single_span_sampling_processor_w_tracer_sampling_after_processing(tracer): """Since the root span has MANUAL_KEEP_KEY set and the child span has not yet run through the TraceSamplingProcessor, the child span will have the manual keep in its context and therefore skip single span sampling. This leads to span sampling rates matching the reality of what span sampling @@ -644,7 +631,6 @@ def test_single_span_sampling_processor_w_tracer_sampling_after_processing(): rules = [rule_1] processor = TraceSamplingProcessor(False, rules, False) processor.sampler.rules = [TraceSamplingRule(sample_rate=0.0)] - tracer = DummyTracer() switch_out_trace_sampling_processor(tracer, processor) root = tracer.trace("root") @@ -664,9 +650,8 @@ def test_single_span_sampling_processor_w_tracer_sampling_after_processing(): assert child.context.sampling_priority == USER_KEEP -def test_single_span_sampling_processor_no_rules(): +def test_single_span_sampling_processor_no_rules(tracer): """Test that single span sampling rules aren't applied if a span is already going to be sampled by trace sampler""" - tracer = DummyTracer() span = traced_function(tracer, trace_sampling_priority=AUTO_KEEP) @@ -679,13 +664,12 @@ def test_single_span_sampling_processor_no_rules(): ) -def test_single_span_sampling_processor_w_stats_computation(): +def test_single_span_sampling_processor_w_stats_computation(tracer): """Test that span processor does not modify the sampling priority when stats computation is enabled""" rule_1 = SpanSamplingRule(service="test_service", name="test_name", sample_rate=1.0, max_per_second=-1) rules = [rule_1] processor = TraceSamplingProcessor(True, rules, False) processor.sampler.rules = [TraceSamplingRule(sample_rate=0.0)] - tracer = DummyTracer() switch_out_trace_sampling_processor(tracer, processor) span = traced_function(tracer) @@ -752,8 +736,7 @@ def test_endpoint_call_counter_processor_disabled(): assert processor.reset()[0] == {} -def test_endpoint_call_counter_processor_real_tracer(): - tracer = DummyTracer() +def test_endpoint_call_counter_processor_real_tracer(tracer): tracer._endpoint_call_counter_span_processor.enable() with tracer.trace("parent", service="top_level_test_service", resource="a", span_type=SpanTypes.WEB): @@ -775,9 +758,7 @@ def test_endpoint_call_counter_processor_real_tracer(): assert tracer._endpoint_call_counter_span_processor.reset()[0] == {"a": 2, "b": 1} -def test_trace_tag_processor_adds_chunk_root_tags(): - tracer = DummyTracer() - +def test_trace_tag_processor_adds_chunk_root_tags(tracer): with tracer.trace("parent") as parent: with tracer.trace("child") as child: pass @@ -787,7 +768,7 @@ def test_trace_tag_processor_adds_chunk_root_tags(): assert child.get_tag("language") is None -def test_register_unregister_span_processor(): +def test_register_unregister_span_processor(tracer): class TestProcessor(SpanProcessor): def on_span_start(self, span): span.set_tag("on_start", "ok") @@ -798,8 +779,6 @@ def on_span_finish(self, span): tp = TestProcessor() tp.register() - tracer = DummyTracer() - with tracer.trace("test") as span: assert span.get_tag("on_start") == "ok" assert span.get_tag("on_finish") == "ok" diff --git a/tests/tracer/test_sampler.py b/tests/tracer/test_sampler.py index ba3a9a6ee0a..494be6d2a18 100644 --- a/tests/tracer/test_sampler.py +++ b/tests/tracer/test_sampler.py @@ -27,11 +27,6 @@ from ..utils import override_global_config -@pytest.fixture -def dummy_tracer(): - return DummyTracer() - - def assert_sampling_decision_tags( span, agent=None, @@ -86,9 +81,8 @@ def test_set_sample_rate(self): sampler.set_sample_rate(str(rate)) assert sampler.sample_rate == float(rate), "The rate can be set as a string" - def test_deterministic_behavior(self): + def test_deterministic_behavior(self, tracer): """Test that for a given trace ID, the result is always the same""" - tracer = DummyTracer() # Since RateSampler does not set the sampling priority on a span, we will use a DatadogSampler # with rate limiting disabled. tracer._sampler = DatadogSampler(rules=[SamplingRule(sample_rate=0.75)], rate_limit=-1) @@ -136,13 +130,11 @@ def test_deterministic_behavior_with_list_of_trace_ids(self): f"and RateSampler:{rate_sample_decision}" ) - def test_negative_sample_rate_raises_error(self): - tracer = DummyTracer() + def test_negative_sample_rate_raises_error(self, tracer): tracer._sampler = RateSampler(sample_rate=-0.5) assert tracer._sampler.sample_rate == 0 - def test_sample_rate_0_does_not_reset_to_1(self): - tracer = DummyTracer() + def test_sample_rate_0_does_not_reset_to_1(self, tracer): tracer._sampler = RateSampler(sample_rate=0) assert tracer._sampler.sample_rate == 0, ( "Setting the sample rate to zero should result in the sample rate being zero" @@ -633,13 +625,13 @@ def test_datadog_sampler_init(): @mock.patch("ddtrace._trace.sampler.RateSampler.sample") -def test_datadog_sampler_sample_no_rules(mock_sample, dummy_tracer): +def test_datadog_sampler_sample_no_rules(mock_sample, tracer): sampler = DatadogSampler() - dummy_tracer._sampler = sampler + tracer._sampler = sampler mock_sample.return_value = True - dummy_tracer.trace("test").finish() - spans = dummy_tracer.pop() + tracer.trace("test").finish() + spans = tracer.pop() assert len(spans) == 1, "Span should have been written" assert_sampling_decision_tags( spans[0], @@ -651,8 +643,8 @@ def test_datadog_sampler_sample_no_rules(mock_sample, dummy_tracer): ) mock_sample.return_value = False - dummy_tracer.trace("test").finish() - spans = dummy_tracer.pop() + tracer.trace("test").finish() + spans = tracer.pop() assert len(spans) == 1, "Span should have been written" assert_sampling_decision_tags( spans[0], @@ -787,10 +779,10 @@ def sample(self, span): ), ], ) -def test_datadog_sampler_sample_rules(sampler, sampling_priority, sampling_mechanism, rule, limit, dummy_tracer): - dummy_tracer._sampler = sampler - dummy_tracer.trace("span").finish() - spans = dummy_tracer.pop() +def test_datadog_sampler_sample_rules(sampler, sampling_priority, sampling_mechanism, rule, limit, tracer): + tracer._sampler = sampler + tracer.trace("span").finish() + spans = tracer.pop() assert len(spans) > 0, "A tracer using DatadogSampler should always emit its spans" span = spans[0] assert span.context.sampling_priority is not None, ( @@ -802,15 +794,15 @@ def test_datadog_sampler_sample_rules(sampler, sampling_priority, sampling_mecha ) -def test_datadog_sampler_tracer_child(dummy_tracer): +def test_datadog_sampler_tracer_child(tracer): rule = SamplingRule(sample_rate=1.0) sampler = DatadogSampler(rules=[rule]) - dummy_tracer._sampler = sampler + tracer._sampler = sampler - with dummy_tracer.trace("parent.span"): - dummy_tracer.trace("child.span").finish() + with tracer.trace("parent.span"): + tracer.trace("child.span").finish() - spans = dummy_tracer.pop() + spans = tracer.pop() assert len(spans) == 2, "A tracer using a DatadogSampler should emit all of its spans" assert_sampling_decision_tags( spans[0], @@ -828,12 +820,12 @@ def test_datadog_sampler_tracer_child(dummy_tracer): ) -def test_datadog_sampler_tracer_start_span(dummy_tracer): +def test_datadog_sampler_tracer_start_span(tracer): rule = SamplingRule(sample_rate=1.0) sampler = DatadogSampler(rules=[rule]) - dummy_tracer._sampler = sampler - dummy_tracer.start_span("test.span").finish() - spans = dummy_tracer.pop() + tracer._sampler = sampler + tracer.start_span("test.span").finish() + spans = tracer.pop() assert len(spans) == 1, "A tracer using a DatadogSampler should emit all of its spans" assert_sampling_decision_tags( spans[0], diff --git a/tests/tracer/test_single_span_sampling_rules.py b/tests/tracer/test_single_span_sampling_rules.py index 7fcd0ef7a54..37206d93a57 100644 --- a/tests/tracer/test_single_span_sampling_rules.py +++ b/tests/tracer/test_single_span_sampling_rules.py @@ -121,35 +121,32 @@ def test_rule_init_via_env_json_not_valid(): assert get_span_sampling_rules() == [] -def test_env_rules_cause_matching_span_to_be_sampled(): +def test_env_rules_cause_matching_span_to_be_sampled(tracer): """Test that single span sampling tags are applied to spans that should get sampled when envars set""" with override_global_config(dict(_sampling_rules='[{"service":"test_service","name":"test_name"}]')): sampling_rules = get_span_sampling_rules() assert sampling_rules[0]._service_matcher.pattern == "test_service" assert sampling_rules[0]._name_matcher.pattern == "test_name" - tracer = DummyTracer() span = traced_function(sampling_rules[0], tracer=tracer) assert_sampling_decision_tags(span) -def test_env_rules_dont_cause_non_matching_span_to_be_sampled(): +def test_env_rules_dont_cause_non_matching_span_to_be_sampled(tracer): """Test that single span sampling tags are not applied to spans that do not match rules""" with override_global_config(dict(_sampling_rules='[{"service":"test_ser","name":"test_na"}]')): sampling_rules = get_span_sampling_rules() assert sampling_rules[0]._service_matcher.pattern == "test_ser" assert sampling_rules[0]._name_matcher.pattern == "test_na" - tracer = DummyTracer() span = traced_function(sampling_rules[0], tracer=tracer) assert_sampling_decision_tags(span, sample_rate=None, mechanism=None, limit=None) -def test_single_span_rules_not_applied_when_span_sampled_by_trace_sampling(): +def test_single_span_rules_not_applied_when_span_sampled_by_trace_sampling(tracer): """Test that single span sampling rules aren't applied if a span is already going to be sampled by trace sampler""" with override_global_config(dict(_sampling_rules='[{"service":"test_service","name":"test_name"}]')): sampling_rules = get_span_sampling_rules() assert sampling_rules[0]._service_matcher.pattern == "test_service" assert sampling_rules[0]._name_matcher.pattern == "test_name" - tracer = DummyTracer() span = traced_function(sampling_rules[0], tracer=tracer, trace_sampling=True) assert sampling_rules[0].match(span) is True assert_sampling_decision_tags(span, sample_rate=None, mechanism=None, limit=None, trace_sampling=True) @@ -304,17 +301,15 @@ def test_single_span_rule_unsupported_pattern_escape_character_literal_evaluatio assert_sampling_decision_tags(span) -def test_multiple_span_rule_match(): +def test_multiple_span_rule_match(tracer): rule = SpanSamplingRule(service="test_service", name="test_name", sample_rate=1.0, max_per_second=-1) - tracer = DummyTracer() for _ in range(10): span = traced_function(rule, tracer) assert_sampling_decision_tags(span) -def test_single_span_rules_not_applied_if_span_dropped_by_single_span_rate_limiter(): +def test_single_span_rules_not_applied_if_span_dropped_by_single_span_rate_limiter(tracer): rule = SpanSamplingRule(service="test_service", name="test_name", sample_rate=1.0, max_per_second=0) - tracer = DummyTracer() for _ in range(10): span = traced_function(rule, tracer) assert_sampling_decision_tags(span, sample_rate=None, mechanism=None, limit=None) @@ -334,9 +329,8 @@ def test_max_per_sec_with_is_allowed_check(): assert_sampling_decision_tags(rate_limited_span, sample_rate=None, mechanism=None, limit=None) -def test_max_per_sec_with_predetermined_number_of_spans(): +def test_max_per_sec_with_predetermined_number_of_spans(tracer): rule = SpanSamplingRule(service="test_service", name="test_name", sample_rate=1.0, max_per_second=2) - tracer = DummyTracer() for i in range(3): span = traced_function(rule, tracer) if i < 2: diff --git a/tests/tracer/test_tracer.py b/tests/tracer/test_tracer.py index 9ef00bb0e0f..7e17aef8682 100644 --- a/tests/tracer/test_tracer.py +++ b/tests/tracer/test_tracer.py @@ -782,12 +782,10 @@ def task(t, errors): assert len(t._span_aggregator.writer._encoder) == 1 -def test_tracer_with_version(): - t = DummyTracer() - +def test_tracer_with_version(tracer): # With global `config.version` defined with override_global_config(dict(version="1.2.3")): - with t.trace("test.span") as span: + with tracer.trace("test.span") as span: assert span.get_tag(VERSION_KEY) == "1.2.3" # override manually @@ -795,7 +793,7 @@ def test_tracer_with_version(): assert span.get_tag(VERSION_KEY) == "4.5.6" # With no `config.version` defined - with t.trace("test.span") as span: + with tracer.trace("test.span") as span: assert span.get_tag(VERSION_KEY) is None # explicitly set in the span @@ -803,18 +801,16 @@ def test_tracer_with_version(): assert span.get_tag(VERSION_KEY) == "1.2.3" # With global tags set - t.set_tags({VERSION_KEY: "tags.version"}) + tracer.set_tags({VERSION_KEY: "tags.version"}) with override_global_config(dict(version="config.version")): - with t.trace("test.span") as span: + with tracer.trace("test.span") as span: assert span.get_tag(VERSION_KEY) == "config.version" -def test_tracer_with_env(): - t = DummyTracer() - +def test_tracer_with_env(tracer): # With global `config.env` defined with override_global_config(dict(env="prod")): - with t.trace("test.span") as span: + with tracer.trace("test.span") as span: assert span.get_tag(ENV_KEY) == "prod" # override manually @@ -822,7 +818,7 @@ def test_tracer_with_env(): assert span.get_tag(ENV_KEY) == "prod-staging" # With no `config.env` defined - with t.trace("test.span") as span: + with tracer.trace("test.span") as span: assert span.get_tag(ENV_KEY) is None # explicitly set in the span @@ -830,9 +826,9 @@ def test_tracer_with_env(): assert span.get_tag(ENV_KEY) == "prod-staging" # With global tags set - t.set_tags({ENV_KEY: "tags.env"}) + tracer.set_tags({ENV_KEY: "tags.env"}) with override_global_config(dict(env="config.env")): - with t.trace("test.span") as span: + with tracer.trace("test.span") as span: assert span.get_tag(ENV_KEY) == "config.env" @@ -1082,9 +1078,7 @@ def thread_target(): t.join(60) -def test_runtime_id_parent_only(): - tracer = DummyTracer() - +def test_runtime_id_parent_only(tracer): # Parent spans should have runtime-id with tracer.trace("test") as s: rtid = s.get_tag("runtime-id")