def test_dd_service_mapping(self):
c = Config()
assert c.service_mapping == {}
with override_env(dict(DD_SERVICE_MAPPING="foobar:bar,snafu:foo")):
c = Config()
assert c.service_mapping == {"foobar": "bar", "snafu": "foo"}
def test_environment_analytics_enabled(self):
# default
self.assertFalse(self.config.analytics_enabled)
self.assertIsNone(self.config.foo.analytics_enabled)
with self.override_env(dict(DD_ANALYTICS_ENABLED='True')):
config = Config()
self.assertTrue(config.analytics_enabled)
self.assertIsNone(config.foo.analytics_enabled)
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED='True')):
config = Config()
self.assertTrue(config.foo.analytics_enabled)
self.assertEqual(config.foo.analytics_sample_rate, 1.0)
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED='False')):
config = Config()
self.assertFalse(config.foo.analytics_enabled)
with self.override_env(
dict(DD_FOO_ANALYTICS_ENABLED='True',
DD_FOO_ANALYTICS_SAMPLE_RATE='0.5')):
config = Config()
self.assertTrue(config.foo.analytics_enabled)
self.assertEqual(config.foo.analytics_sample_rate, 0.5)
def test_get_analytics_sample_rate(self):
"""" Check method for accessing sample rate based on configuration """
ic = IntegrationConfig(self.config, "foo", analytics_enabled=True, analytics_sample_rate=0.5)
self.assertEqual(ic.get_analytics_sample_rate(), 0.5)
ic = IntegrationConfig(self.config, "foo", analytics_enabled=True)
self.assertEqual(ic.get_analytics_sample_rate(), 1.0)
ic = IntegrationConfig(self.config, "foo", analytics_enabled=False)
self.assertIsNone(ic.get_analytics_sample_rate())
with self.override_env(dict(DD_ANALYTICS_ENABLED="True")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertEqual(ic.get_analytics_sample_rate(use_global_config=True), 1.0)
with self.override_env(dict(DD_TRACE_ANALYTICS_ENABLED="True")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertEqual(ic.get_analytics_sample_rate(use_global_config=True), 1.0)
with self.override_env(dict(DD_ANALYTICS_ENABLED="False")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertIsNone(ic.get_analytics_sample_rate(use_global_config=True))
with self.override_env(dict(DD_TRACE_ANALYTICS_ENABLED="False")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertIsNone(ic.get_analytics_sample_rate(use_global_config=True))
def test_environment_analytics_enabled(self):
with self.override_env(dict(DD_ANALYTICS_ENABLED='True')):
config = Config()
self.assertTrue(config.analytics_enabled)
with self.override_env(dict(DD_ANALYTICS_ENABLED='False')):
config = Config()
self.assertFalse(config.analytics_enabled)
def test_logs_injection(self):
with self.override_env(dict(DD_LOGS_INJECTION="True")):
config = Config()
self.assertTrue(config.logs_injection)
with self.override_env(dict(DD_LOGS_INJECTION="false")):
config = Config()
self.assertFalse(config.logs_injection)
def test_service(self):
# If none is provided the default should be ``None``
with self.override_env(dict()):
config = Config()
self.assertEqual(config.service, None)
with self.override_env(dict(DD_SERVICE="my-service")):
config = Config()
self.assertEqual(config.service, "my-service")
def test_dd_version(self):
c = Config()
assert c.version is None
with override_env(dict(DD_VERSION="1.2.3")):
c = Config()
assert c.version == "1.2.3"
c.version = "4.5.6"
assert c.version == "4.5.6"
def test_allow_exist_both_global_and_integration_config(self):
global_config = Config()
integration_config = IntegrationConfig(global_config)
global_config.trace_headers('global_header')
assert integration_config.header_is_traced('global_header')
integration_config.http.trace_headers('integration_header')
assert integration_config.header_is_traced('integration_header')
assert not integration_config.header_is_traced('global_header')
assert not global_config.header_is_traced('integration_header')
def test_dd_env(self):
c = Config()
assert c.env is None
with override_env(dict(DD_ENV="prod")):
c = Config()
assert c.env == "prod"
# manual override still possible
c.env = "prod-staging"
assert c.env == "prod-staging"
def test_environment_header_tags():
with override_env(
dict(
DD_TRACE_HEADER_TAGS="Host:http.host,User-agent:http.user_agent"
)):
config = Config()
assert config.http.is_header_tracing_configured
assert config._header_tag_name("Host") == "http.host"
assert config._header_tag_name("User-agent") == "http.user_agent"
# Case insensitive
assert config._header_tag_name("User-Agent") == "http.user_agent"
def test_config_is_header_tracing_configured(global_headers, int_headers,
expected):
config = Config()
integration_config = config.myint
if global_headers is not None:
config.trace_headers(global_headers)
if int_headers is not None:
integration_config.http.trace_headers(int_headers)
assert (
config.http.is_header_tracing_configured,
integration_config.http.is_header_tracing_configured,
integration_config.is_header_tracing_configured,
) == expected
def test_allow_attr_access(self):
config = IntegrationConfig(Config())
config.setting = 'value'
# Can be accessed both as item and attr accessor
assert config.setting == 'value'
assert config['setting'] == 'value'
def test_environment_analytics_overrides(self):
with self.override_env(dict(DD_ANALYTICS_ENABLED="False", DD_TRACE_ANALYTICS_ENABLED="True")):
config = Config()
self.assertTrue(config.analytics_enabled)
with self.override_env(dict(DD_ANALYTICS_ENABLED="False", DD_TRACE_ANALYTICS_ENABLED="False")):
config = Config()
self.assertFalse(config.analytics_enabled)
with self.override_env(dict(DD_ANALYTICS_ENABLED="True", DD_TRACE_ANALYTICS_ENABLED="True")):
config = Config()
self.assertTrue(config.analytics_enabled)
with self.override_env(dict(DD_ANALYTICS_ENABLED="True", DD_TRACE_ANALYTICS_ENABLED="False")):
config = Config()
self.assertFalse(config.analytics_enabled)
def test_allow_both_access(self):
config = IntegrationConfig(Config())
config.setting = 'value'
assert config['setting'] == 'value'
assert config.setting == 'value'
config['setting'] = 'new-value'
assert config.setting == 'new-value'
assert config['setting'] == 'new-value'
class GlobalConfigTestCase(TestCase):
"""Test the `Configuration` class that stores integration settings"""
def setUp(self):
self.config = Config()
def test_registration(self):
# ensure an integration can register a new list of settings
settings = {
'distributed_tracing': True,
}
self.config._add('requests', settings)
ok_(self.config.requests['distributed_tracing'] is True)
def test_settings_copy(self):
# ensure that once an integration is registered, a copy
# of the settings is stored to avoid side-effects
experimental = {
'request_enqueuing': True,
}
settings = {
'distributed_tracing': True,
'experimental': experimental,
}
self.config._add('requests', settings)
settings['distributed_tracing'] = False
experimental['request_enqueuing'] = False
ok_(self.config.requests['distributed_tracing'] is True)
ok_(self.config.requests['experimental']['request_enqueuing'] is True)
def test_missing_integration(self):
# ensure a meaningful exception is raised when an integration
# that is not available is retrieved in the configuration
# object
with assert_raises(ConfigException) as e:
self.config.new_integration['some_key']
ok_(isinstance(e.exception, ConfigException))
def test_global_configuration(self):
# ensure a global configuration is available in the `ddtrace` module
ok_(isinstance(global_config, Config))
def test_get_analytics_sample_rate_deprecated_name(self):
"""Check method for accessing sample rate based on configuration"""
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED="True")):
config = Config()
ic = IntegrationConfig(config, "bar", _deprecated_name="foo")
self.assertEqual(ic.get_analytics_sample_rate(), 1.0)
with self.override_env(dict(DD_TRACE_FOO_ANALYTICS_ENABLED="True")):
config = Config()
ic = IntegrationConfig(config, "bar", _deprecated_name="foo")
self.assertEqual(ic.get_analytics_sample_rate(), 1.0)
with self.override_env(
dict(DD_FOO_ANALYTICS_ENABLED="True",
DD_FOO_ANALYTICS_SAMPLE_RATE="0.5")):
config = Config()
ic = IntegrationConfig(config, "bar", _deprecated_name="foo")
self.assertEqual(ic.get_analytics_sample_rate(), 0.5)
with self.override_env(
dict(DD_FOO_ANALYTICS_ENABLED="True",
DD_TRACE_FOO_ANALYTICS_SAMPLE_RATE="0.5")):
config = Config()
ic = IntegrationConfig(config, "bar", _deprecated_name="foo")
self.assertEqual(ic.get_analytics_sample_rate(), 0.5)
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED="False")):
config = Config()
ic = IntegrationConfig(config, "bar", _deprecated_name="foo")
self.assertIsNone(ic.get_analytics_sample_rate())
with self.override_env(dict(DD_TRACE_FOO_ANALYTICS_ENABLED="False")):
config = Config()
ic = IntegrationConfig(config, "bar", _deprecated_name="foo")
self.assertIsNone(ic.get_analytics_sample_rate())
def test_http_config(self):
config = Config()
config._add("django", dict())
assert config.django.trace_query_string is None
config.http.trace_query_string = True
assert config.http.trace_query_string is True
assert config.django.trace_query_string is True
# Integration usage
config = Config()
config._add("django", dict())
config.django.http.trace_query_string = True
assert config.http.trace_query_string is None
assert config.django.trace_query_string is True
assert config.django.http.trace_query_string is True
def test_dd_env(self):
c = Config()
assert c.env is None
with override_env(dict(DD_ENV="prod")):
c = Config()
assert c.env == "prod"
# manual override still possible
c.env = "prod-staging"
assert c.env == "prod-staging"
# between DD_ENV and DATADOG_ENV, the former takes priority
with override_env(dict(DATADOG_ENV="prod", DD_ENV="prod-staging")):
c = Config()
assert c.env == "prod-staging"
def test_is_a_dict(self):
integration_config = IntegrationConfig(Config())
assert isinstance(integration_config, dict)
def config(self):
yield Config()
def config():
c = Config()
c._add("myint", dict())
return c
def setUp(self):
self.config = Config()
class GlobalConfigTestCase(TestCase):
"""Test the `Configuration` class that stores integration settings"""
def setUp(self):
self.config = Config()
self.tracer = get_dummy_tracer()
def test_registration(self):
# ensure an integration can register a new list of settings
settings = {
'distributed_tracing': True,
}
self.config._add('requests', settings)
assert self.config.requests['distributed_tracing'] is True
def test_settings_copy(self):
# ensure that once an integration is registered, a copy
# of the settings is stored to avoid side-effects
experimental = {
'request_enqueuing': True,
}
settings = {
'distributed_tracing': True,
'experimental': experimental,
}
self.config._add('requests', settings)
settings['distributed_tracing'] = False
experimental['request_enqueuing'] = False
assert self.config.requests['distributed_tracing'] is True
assert self.config.requests['experimental']['request_enqueuing'] is True
def test_missing_integration_key(self):
# ensure a meaningful exception is raised when an integration
# that is not available is retrieved in the configuration
# object
with pytest.raises(KeyError) as e:
self.config.new_integration['some_key']
assert isinstance(e.value, KeyError)
def test_global_configuration(self):
# ensure a global configuration is available in the `ddtrace` module
assert isinstance(global_config, Config)
def test_settings_merge(self):
"""
When calling `config._add()`
when existing settings exist
we do not overwrite the existing settings
"""
self.config.requests['split_by_domain'] = True
self.config._add('requests', dict(split_by_domain=False))
assert self.config.requests['split_by_domain'] is True
def test_settings_overwrite(self):
"""
When calling `config._add(..., merge=False)`
when existing settings exist
we overwrite the existing settings
"""
self.config.requests['split_by_domain'] = True
self.config._add('requests', dict(split_by_domain=False), merge=False)
assert self.config.requests['split_by_domain'] is False
def test_settings_merge_deep(self):
"""
When calling `config._add()`
when existing "deep" settings exist
we do not overwrite the existing settings
"""
self.config.requests['a'] = dict(
b=dict(
c=True,
),
)
self.config._add('requests', dict(
a=dict(
b=dict(
c=False,
d=True,
),
),
))
assert self.config.requests['a']['b']['c'] is True
assert self.config.requests['a']['b']['d'] is True
def test_settings_hook(self):
"""
When calling `Hooks._emit()`
When there is a hook registered
we call the hook as expected
"""
# Setup our hook
@self.config.web.hooks.on('request')
def on_web_request(span):
span.set_tag('web.request', '/')
# Create our span
span = self.tracer.start_span('web.request')
assert 'web.request' not in span.meta
# Emit the span
self.config.web.hooks._emit('request', span)
# Assert we updated the span as expected
assert span.get_tag('web.request') == '/'
def test_settings_hook_args(self):
"""
When calling `Hooks._emit()` with arguments
When there is a hook registered
we call the hook as expected
"""
# Setup our hook
@self.config.web.hooks.on('request')
def on_web_request(span, request, response):
span.set_tag('web.request', request)
span.set_tag('web.response', response)
# Create our span
span = self.tracer.start_span('web.request')
assert 'web.request' not in span.meta
# Emit the span
# DEV: The actual values don't matter, we just want to test args + kwargs usage
self.config.web.hooks._emit('request', span, 'request', response='response')
# Assert we updated the span as expected
assert span.get_tag('web.request') == 'request'
assert span.get_tag('web.response') == 'response'
def test_settings_hook_args_failure(self):
"""
When calling `Hooks._emit()` with arguments
When there is a hook registered that is missing parameters
we do not raise an exception
"""
# Setup our hook
# DEV: We are missing the required "response" argument
@self.config.web.hooks.on('request')
def on_web_request(span, request):
span.set_tag('web.request', request)
# Create our span
span = self.tracer.start_span('web.request')
assert 'web.request' not in span.meta
# Emit the span
# DEV: This also asserts that no exception was raised
self.config.web.hooks._emit('request', span, 'request', response='response')
# Assert we did not update the span
assert 'web.request' not in span.meta
def test_settings_multiple_hooks(self):
"""
When calling `Hooks._emit()`
When there are multiple hooks registered
we do not raise an exception
"""
# Setup our hooks
@self.config.web.hooks.on('request')
def on_web_request(span):
span.set_tag('web.request', '/')
@self.config.web.hooks.on('request')
def on_web_request2(span):
span.set_tag('web.status', 200)
@self.config.web.hooks.on('request')
def on_web_request3(span):
span.set_tag('web.method', 'GET')
# Create our span
span = self.tracer.start_span('web.request')
assert 'web.request' not in span.meta
assert 'web.status' not in span.metrics
assert 'web.method' not in span.meta
# Emit the span
self.config.web.hooks._emit('request', span)
# Assert we updated the span as expected
assert span.get_tag('web.request') == '/'
assert span.get_metric('web.status') == 200
assert span.get_tag('web.method') == 'GET'
def test_settings_hook_failure(self):
"""
When calling `Hooks._emit()`
When the hook raises an exception
we do not raise an exception
"""
# Setup our failing hook
on_web_request = mock.Mock(side_effect=Exception)
self.config.web.hooks.register('request')(on_web_request)
# Create our span
span = self.tracer.start_span('web.request')
# 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):
"""
When calling `Hooks._emit()`
When no hook is registered
we do not raise an exception
"""
# Create our span
span = self.tracer.start_span('web.request')
# Emit the span
# DEV: This is the test, to ensure no exceptions are raised
self.config.web.hooks._emit('request', span)
def test_settings_no_span(self):
"""
When calling `Hooks._emit()`
When no span is provided
we do not raise an exception
"""
# Setup our hooks
@self.config.web.hooks.on('request')
def on_web_request(span):
span.set_tag('web.request', '/')
# Emit the span
# DEV: This is the test, to ensure no exceptions are raised
self.config.web.hooks._emit('request', None)
def test_allow_configuring_http(self):
global_config = Config()
integration_config = IntegrationConfig(global_config)
integration_config.http.trace_headers('integration_header')
assert integration_config.http.header_is_traced('integration_header')
assert not integration_config.http.header_is_traced('other_header')
def setUp(self):
self.config = Config()
self.tracer = DummyTracer()
class TestIntegrationConfig(BaseTestCase):
def setUp(self):
self.config = Config()
self.integration_config = IntegrationConfig(self.config, "test")
def test_is_a_dict(self):
assert isinstance(self.integration_config, dict)
def test_allow_item_access(self):
self.integration_config["setting"] = "value"
# Can be accessed both as item and attr accessor
assert self.integration_config.setting == "value"
assert self.integration_config["setting"] == "value"
def test_allow_attr_access(self):
self.integration_config.setting = "value"
# Can be accessed both as item and attr accessor
assert self.integration_config.setting == "value"
assert self.integration_config["setting"] == "value"
def test_allow_both_access(self):
self.integration_config.setting = "value"
assert self.integration_config["setting"] == "value"
assert self.integration_config.setting == "value"
self.integration_config["setting"] = "new-value"
assert self.integration_config.setting == "new-value"
assert self.integration_config["setting"] == "new-value"
def test_allow_configuring_http(self):
self.integration_config.http.trace_headers("integration_header")
assert self.integration_config.http.header_is_traced("integration_header")
assert not self.integration_config.http.header_is_traced("other_header")
def test_allow_exist_both_global_and_integration_config(self):
self.config.trace_headers("global_header")
assert self.integration_config.header_is_traced("global_header")
self.integration_config.http.trace_headers("integration_header")
assert self.integration_config.header_is_traced("integration_header")
assert not self.integration_config.header_is_traced("global_header")
assert not self.config.header_is_traced("integration_header")
def test_environment_analytics_enabled(self):
# default
self.assertFalse(self.config.analytics_enabled)
self.assertIsNone(self.config.foo.analytics_enabled)
with self.override_env(dict(DD_ANALYTICS_ENABLED="True")):
config = Config()
self.assertTrue(config.analytics_enabled)
self.assertIsNone(config.foo.analytics_enabled)
with self.override_env(dict(DD_TRACE_ANALYTICS_ENABLED="True")):
config = Config()
self.assertTrue(config.analytics_enabled)
self.assertIsNone(config.foo.analytics_enabled)
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED="True")):
config = Config()
self.assertTrue(config.foo.analytics_enabled)
self.assertEqual(config.foo.analytics_sample_rate, 1.0)
with self.override_env(dict(DD_TRACE_FOO_ANALYTICS_ENABLED="True")):
config = Config()
self.assertTrue(config.foo.analytics_enabled)
self.assertEqual(config.foo.analytics_sample_rate, 1.0)
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED="False")):
config = Config()
self.assertFalse(config.foo.analytics_enabled)
with self.override_env(dict(DD_TRACE_FOO_ANALYTICS_ENABLED="False")):
config = Config()
self.assertFalse(config.foo.analytics_enabled)
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED="True", DD_FOO_ANALYTICS_SAMPLE_RATE="0.5")):
config = Config()
self.assertTrue(config.foo.analytics_enabled)
self.assertEqual(config.foo.analytics_sample_rate, 0.5)
with self.override_env(dict(DD_TRACE_FOO_ANALYTICS_ENABLED="True", DD_TRACE_FOO_ANALYTICS_SAMPLE_RATE="0.5")):
config = Config()
self.assertTrue(config.foo.analytics_enabled)
self.assertEqual(config.foo.analytics_sample_rate, 0.5)
def test_analytics_enabled_attribute(self):
"""" Confirm environment variable and kwargs are handled properly """
ic = IntegrationConfig(self.config, "foo", analytics_enabled=True)
self.assertTrue(ic.analytics_enabled)
ic = IntegrationConfig(self.config, "foo", analytics_enabled=False)
self.assertFalse(ic.analytics_enabled)
with self.override_env(dict(DD_FOO_ANALYTICS_ENABLED="True")):
ic = IntegrationConfig(self.config, "foo", analytics_enabled=False)
self.assertFalse(ic.analytics_enabled)
with self.override_env(dict(DD_TRACE_FOO_ANALYTICS_ENABLED="True")):
ic = IntegrationConfig(self.config, "foo", analytics_enabled=False)
self.assertFalse(ic.analytics_enabled)
def test_get_analytics_sample_rate(self):
"""" Check method for accessing sample rate based on configuration """
ic = IntegrationConfig(self.config, "foo", analytics_enabled=True, analytics_sample_rate=0.5)
self.assertEqual(ic.get_analytics_sample_rate(), 0.5)
ic = IntegrationConfig(self.config, "foo", analytics_enabled=True)
self.assertEqual(ic.get_analytics_sample_rate(), 1.0)
ic = IntegrationConfig(self.config, "foo", analytics_enabled=False)
self.assertIsNone(ic.get_analytics_sample_rate())
with self.override_env(dict(DD_ANALYTICS_ENABLED="True")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertEqual(ic.get_analytics_sample_rate(use_global_config=True), 1.0)
with self.override_env(dict(DD_TRACE_ANALYTICS_ENABLED="True")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertEqual(ic.get_analytics_sample_rate(use_global_config=True), 1.0)
with self.override_env(dict(DD_ANALYTICS_ENABLED="False")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertIsNone(ic.get_analytics_sample_rate(use_global_config=True))
with self.override_env(dict(DD_TRACE_ANALYTICS_ENABLED="False")):
config = Config()
ic = IntegrationConfig(config, "foo")
self.assertIsNone(ic.get_analytics_sample_rate(use_global_config=True))
def test_service(self):
ic = IntegrationConfig(self.config, "foo")
assert ic.service is None
@BaseTestCase.run_in_subprocess(env_overrides=dict(DD_FOO_SERVICE="foo-svc"))
def test_service_env_var(self):
ic = IntegrationConfig(self.config, "foo")
assert ic.service == "foo-svc"
@BaseTestCase.run_in_subprocess(env_overrides=dict(DATADOG_FOO_SERVICE="foo-svc"))
def test_service_env_var_legacy(self):
ic = IntegrationConfig(self.config, "foo")
assert ic.service == "foo-svc"
@BaseTestCase.run_in_subprocess(env_overrides=dict(DD_FOO_SERVICE_NAME="foo-svc"))
def test_service_name_env_var(self):
ic = IntegrationConfig(self.config, "foo")
assert ic.service == "foo-svc"
@BaseTestCase.run_in_subprocess(env_overrides=dict(DATADOG_FOO_SERVICE_NAME="foo-svc"))
def test_service_name_env_var_legacy(self):
ic = IntegrationConfig(self.config, "foo")
assert ic.service == "foo-svc"
class GlobalConfigTestCase(TestCase):
"""Test the `Configuration` class that stores integration settings"""
def setUp(self):
self.config = Config()
self.tracer = get_dummy_tracer()
def test_registration(self):
# ensure an integration can register a new list of settings
settings = {
"distributed_tracing": True,
}
self.config._add("requests", settings)
assert self.config.requests["distributed_tracing"] is True
def test_settings_copy(self):
# ensure that once an integration is registered, a copy
# of the settings is stored to avoid side-effects
experimental = {
"request_enqueuing": True,
}
settings = {
"distributed_tracing": True,
"experimental": experimental,
}
self.config._add("requests", settings)
settings["distributed_tracing"] = False
experimental["request_enqueuing"] = False
assert self.config.requests["distributed_tracing"] is True
assert self.config.requests["experimental"]["request_enqueuing"] is True
def test_missing_integration_key(self):
# ensure a meaningful exception is raised when an integration
# that is not available is retrieved in the configuration
# object
with pytest.raises(KeyError) as e:
self.config.new_integration["some_key"]
assert isinstance(e.value, KeyError)
def test_global_configuration(self):
# ensure a global configuration is available in the `ddtrace` module
assert isinstance(global_config, Config)
def test_settings_merge(self):
"""
When calling `config._add()`
when existing settings exist
we do not overwrite the existing settings
"""
self.config.requests["split_by_domain"] = True
self.config._add("requests", dict(split_by_domain=False))
assert self.config.requests["split_by_domain"] is True
def test_settings_overwrite(self):
"""
When calling `config._add(..., merge=False)`
when existing settings exist
we overwrite the existing settings
"""
self.config.requests["split_by_domain"] = True
self.config._add("requests", dict(split_by_domain=False), merge=False)
assert self.config.requests["split_by_domain"] is False
def test_settings_merge_deep(self):
"""
When calling `config._add()`
when existing "deep" settings exist
we do not overwrite the existing settings
"""
self.config.requests["a"] = dict(
b=dict(
c=True,
),
)
self.config._add(
"requests",
dict(
a=dict(
b=dict(
c=False,
d=True,
),
),
),
)
assert self.config.requests["a"]["b"]["c"] is True
assert self.config.requests["a"]["b"]["d"] is True
def test_settings_hook(self):
"""
When calling `Hooks.emit()`
When there is a hook registered
we call the hook as expected
"""
# Setup our hook
@self.config.web.hooks.on("request")
def on_web_request(span):
span.set_tag("web.request", "/")
# Create our span
span = self.tracer.start_span("web.request")
assert "web.request" not in span.meta
# Emit the span
self.config.web.hooks.emit("request", span)
# Assert we updated the span as expected
assert span.get_tag("web.request") == "/"
def test_settings_hook_args(self):
"""
When calling `Hooks.emit()` with arguments
When there is a hook registered
we call the hook as expected
"""
# Setup our hook
@self.config.web.hooks.on("request")
def on_web_request(span, request, response):
span.set_tag("web.request", request)
span.set_tag("web.response", response)
# Create our span
span = self.tracer.start_span("web.request")
assert "web.request" not in span.meta
# Emit the span
# DEV: The actual values don't matter, we just want to test args + kwargs usage
self.config.web.hooks.emit("request", span, "request", response="response")
# Assert we updated the span as expected
assert span.get_tag("web.request") == "request"
assert span.get_tag("web.response") == "response"
def test_settings_hook_args_failure(self):
"""
When calling `Hooks.emit()` with arguments
When there is a hook registered that is missing parameters
we do not raise an exception
"""
# Setup our hook
# DEV: We are missing the required "response" argument
@self.config.web.hooks.on("request")
def on_web_request(span, request):
span.set_tag("web.request", request)
# Create our span
span = self.tracer.start_span("web.request")
assert "web.request" not in span.meta
# Emit the span
# DEV: This also asserts that no exception was raised
self.config.web.hooks.emit("request", span, "request", response="response")
# Assert we did not update the span
assert "web.request" not in span.meta
def test_settings_multiple_hooks(self):
"""
When calling `Hooks.emit()`
When there are multiple hooks registered
we do not raise an exception
"""
# Setup our hooks
@self.config.web.hooks.on("request")
def on_web_request(span):
span.set_tag("web.request", "/")
@self.config.web.hooks.on("request")
def on_web_request2(span):
span.set_tag("web.status", 200)
@self.config.web.hooks.on("request")
def on_web_request3(span):
span.set_tag("web.method", "GET")
# Create our span
span = self.tracer.start_span("web.request")
assert "web.request" not in span.meta
assert "web.status" not in span.metrics
assert "web.method" not in span.meta
# Emit the span
self.config.web.hooks.emit("request", span)
# Assert we updated the span as expected
assert span.get_tag("web.request") == "/"
assert span.get_metric("web.status") == 200
assert span.get_tag("web.method") == "GET"
def test_settings_hook_failure(self):
"""
When calling `Hooks.emit()`
When the hook raises an exception
we do not raise an exception
"""
# Setup our failing hook
on_web_request = mock.Mock(side_effect=Exception)
self.config.web.hooks.register("request")(on_web_request)
# Create our span
span = self.tracer.start_span("web.request")
# 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):
"""
When calling `Hooks.emit()`
When no hook is registered
we do not raise an exception
"""
# Create our span
span = self.tracer.start_span("web.request")
# Emit the span
# DEV: This is the test, to ensure no exceptions are raised
self.config.web.hooks.emit("request", span)
def test_settings_no_span(self):
"""
When calling `Hooks.emit()`
When no span is provided
we do not raise an exception
"""
# Setup our hooks
@self.config.web.hooks.on("request")
def on_web_request(span):
span.set_tag("web.request", "/")
# Emit the span
# DEV: This is the test, to ensure no exceptions are raised
self.config.web.hooks.emit("request", None)
def test_dd_version(self):
c = Config()
assert c.version is None
with override_env(dict(DD_VERSION="1.2.3")):
c = Config()
assert c.version == "1.2.3"
c.version = "4.5.6"
assert c.version == "4.5.6"
def test_dd_env(self):
c = Config()
assert c.env is None
with override_env(dict(DD_ENV="prod")):
c = Config()
assert c.env == "prod"
# manual override still possible
c.env = "prod-staging"
assert c.env == "prod-staging"
# between DD_ENV and DATADOG_ENV, the former takes priority
with override_env(dict(DATADOG_ENV="prod", DD_ENV="prod-staging")):
c = Config()
assert c.env == "prod-staging"
def setUp(self):
self.config = Config()
self.tracer = get_dummy_tracer()
def setUp(self):
self.config = Config()
self.integration_config = IntegrationConfig(self.config, "test")
def override_service_mapping(service_mapping):
with override_env(dict(DD_SERVICE_MAPPING=service_mapping)):
assert ddtrace.config.service_mapping == {}
ddtrace.config.service_mapping = Config().service_mapping
yield
ddtrace.config.service_mapping = {}
