def arrange_scope_manager(scope_manager):
if scope_manager is None:
try:
import sys
if (sys.version_info[0] > 3) or (sys.version_info[0] == 3
and sys.version_info[1] > 7) or (
sys.version_info[0] == 3
and sys.version_info[1] == 7
and sys.version_info[2] != 0):
from opentracing.scope_managers.contextvars import ContextVarsScopeManager
scope_manager = ContextVarsScopeManager()
else:
scope_manager = ThreadLocalScopeManager()
except Exception:
scope_manager = ThreadLocalScopeManager()
return scope_manager
def __init__(self,
service_name,
recorder,
scope_manager=None,
common_tags=None,
use_shared_spans=False):
"""
Initialize a Haystack Tracer instance.
:param service_name: The service name to which all spans will belong.
:param recorder: The recorder (dispatcher) implementation which handles
finished spans.
:param scope_manager: An optional parameter to override the default
ThreadLocal scope manager.
:param common_tags: An optional dictionary of tags which should be
applied to all created spans for this service
:param use_shared_spans: A boolean indicating whether or not to use
shared spans. This is when client/server spans share the same span id.
Default is to use unique span ids.
"""
scope_manager = ThreadLocalScopeManager() if scope_manager is None \
else scope_manager
super().__init__(scope_manager)
self._propagators = {}
self._common_tags = {} if common_tags is None else common_tags
self.service_name = service_name
self.recorder = recorder
self.use_shared_spans = use_shared_spans
self.register_propagator(Format.TEXT_MAP, TextPropagator())
self.register_propagator(Format.HTTP_HEADERS, TextPropagator())
def __init__(self, service_name=None, config=None, scope_manager=None, dd_tracer=None):
"""Initialize a new Datadog opentracer.
:param service_name: (optional) the name of the service that this
tracer will be used with. Note if not provided, a service name will
try to be determined based off of ``sys.argv``. If this fails a
:class:`ddtrace.settings.ConfigException` will be raised.
:param config: (optional) a configuration object to specify additional
options. See the documentation for further information.
:param scope_manager: (optional) the scope manager for this tracer to
use. The available managers are listed in the Python OpenTracing repo
here: https://github.com/opentracing/opentracing-python#scope-managers.
If ``None`` is provided, defaults to
:class:`opentracing.scope_managers.ThreadLocalScopeManager`.
:param dd_tracer: (optional) the Datadog tracer for this tracer to use. This
should only be passed if a custom Datadog tracer is being used. Defaults
to the global ``ddtrace.tracer`` tracer.
"""
# Merge the given config with the default into a new dict
config = config or {}
self._config = merge_dicts(DEFAULT_CONFIG, config)
# Pull out commonly used properties for performance
self._service_name = service_name or get_application_name()
self._enabled = self._config.get(keys.ENABLED)
self._debug = self._config.get(keys.DEBUG)
if self._debug:
# Ensure there are no typos in any of the keys
invalid_keys = config_invalid_keys(self._config)
if invalid_keys:
str_invalid_keys = ','.join(invalid_keys)
raise ConfigException('invalid key(s) given ({})'.format(str_invalid_keys))
if not self._service_name:
raise ConfigException(""" Cannot detect the \'service_name\'.
Please set the \'service_name=\'
keyword argument.
""")
self._scope_manager = scope_manager or ThreadLocalScopeManager()
dd_context_provider = get_context_provider_for_scope_manager(self._scope_manager)
self._dd_tracer = dd_tracer or ddtrace.tracer or DatadogTracer()
self._dd_tracer.set_tags(self._config.get(keys.GLOBAL_TAGS))
self._dd_tracer.configure(enabled=self._enabled,
hostname=self._config.get(keys.AGENT_HOSTNAME),
https=self._config.get(keys.AGENT_HTTPS),
port=self._config.get(keys.AGENT_PORT),
sampler=self._config.get(keys.SAMPLER),
settings=self._config.get(keys.SETTINGS),
priority_sampling=self._config.get(keys.PRIORITY_SAMPLING),
uds_path=self._config.get(keys.UDS_PATH),
context_provider=dd_context_provider,
)
self._propagators = {
Format.HTTP_HEADERS: HTTPPropagator(),
Format.TEXT_MAP: HTTPPropagator(),
}
def test_tracer_callable_str(self):
settings.OPENTRACING_TRACER_CALLABLE = 'opentracing.mocktracer.MockTracer'
settings.OPENTRACING_TRACER_PARAMETERS = {
'scope_manager': ThreadLocalScopeManager()
}
OpenTracingMiddleware()
assert getattr(settings, 'OPENTRACING_TRACING', None) is not None
assert isinstance(settings.OPENTRACING_TRACING.tracer, MockTracer)
def __init__(self, client_instance=None, config=None, scope_manager=None):
self._agent = client_instance or self._zuqa_client_class(config=config)
if scope_manager and not isinstance(scope_manager, ThreadLocalScopeManager):
warnings.warn(
"Currently, the ZUQA opentracing bridge only supports the ThreadLocalScopeManager. "
"Usage of other scope managers will lead to unpredictable results."
)
self._scope_manager = scope_manager or ThreadLocalScopeManager()
if self._agent.config.instrument and self._agent.config.enabled:
instrument()
def __init__(self, scope_manager: ScopeManager = None):
"""Initialize an EventBasedTracer instance.
Note that the returned EventBasedTracer has *no* propagators registered. The
user should either call register_propagator() for each needed
inject/extract format and/or the user can simply call
register_required_propagators().
The required formats are opt-in because of protobuf version conflicts
with the binary carrier.
"""
scope_manager = ThreadLocalScopeManager() \
if scope_manager is None else scope_manager
super(EventBasedTracer, self).__init__(scope_manager)
self._propagators = {}
def __init__(self, scope_manager=None):
"""Initialize a MockTracer instance."""
scope_manager = ThreadLocalScopeManager() \
if scope_manager is None else scope_manager
super(MockTracer, self).__init__(scope_manager)
self._propagators = {}
self._finished_spans = []
self._spans_lock = Lock()
# Simple-as-possible (consecutive for repeatability) id generation.
self._next_id = 0
self._next_id_lock = Lock()
self._register_required_propagators()
def __init__(self, reporter, application_tags, global_tags=None):
"""
Construct Wavefront Tracer.
:param reporter: Reporter
:type reporter: :class:`Reporter`
:param application_tags: Application Tags
:type application_tags: :class:`ApplicationTags`
:param global_tags: Global tags for the tracer
:type global_tags: list of pair
"""
super(WavefrontTracer, self).__init__(ThreadLocalScopeManager())
self._reporter = reporter
self._tags = global_tags or []
self._tags.extend(application_tags.get_as_list())
self.registry = registry.PropagatorRegistry()
def init_jaeger_tracer() -> Tracer:
config = Config(config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
'propagation': "b3",
'local_agent': {
'reporting_host': 'localhost'
}
},
service_name='service1',
validate=True,
scope_manager=ThreadLocalScopeManager())
return config.initialize_tracer()
def test_tracer_callable_str(self):
tracer_callable = 'opentracing.mocktracer.MockTracer'
tracer_parameters = {
'scope_manager': ThreadLocalScopeManager(),
}
registry = DummyRegistry()
registry.settings['ot.tracer_callable'] = tracer_callable
registry.settings['ot.tracer_parameters'] = tracer_parameters
self._call(registry=registry)
self.assertIsNotNone(registry.settings.get('ot.tracing'))
self.assertIsNotNone(registry.settings.get('ot.tracing').tracer)
tracer = registry.settings['ot.tracing'].tracer
self.assertTrue(isinstance(tracer, MockTracer))
self.assertEqual(tracer_parameters['scope_manager'],
tracer.scope_manager)
def scope_manager(self):
return ThreadLocalScopeManager()
def __init__(
self, service_name, reporter, sampler, metrics=None,
metrics_factory=None,
trace_id_header=constants.TRACE_ID_HEADER,
generate_128bit_trace_id=False,
baggage_header_prefix=constants.BAGGAGE_HEADER_PREFIX,
debug_id_header=constants.DEBUG_ID_HEADER_KEY,
one_span_per_rpc=False, extra_codecs=None,
tags=None,
max_tag_value_length=constants.MAX_TAG_VALUE_LENGTH,
max_traceback_length=constants.MAX_TRACEBACK_LENGTH,
throttler=None,
scope_manager=None,
):
self.service_name = service_name
self.reporter = reporter
self.sampler = sampler
self.metrics_factory = metrics_factory or LegacyMetricsFactory(metrics or Metrics())
self.metrics = TracerMetrics(self.metrics_factory)
self.random = random.Random(time.time() * (os.getpid() or 1))
self.debug_id_header = debug_id_header
self.one_span_per_rpc = one_span_per_rpc
self.max_tag_value_length = max_tag_value_length
self.max_traceback_length = max_traceback_length
self.max_trace_id_bits = constants._max_trace_id_bits if generate_128bit_trace_id \
else constants._max_id_bits
self.codecs = {
Format.TEXT_MAP: TextCodec(
url_encoding=False,
trace_id_header=trace_id_header,
baggage_header_prefix=baggage_header_prefix,
debug_id_header=debug_id_header,
),
Format.HTTP_HEADERS: TextCodec(
url_encoding=True,
trace_id_header=trace_id_header,
baggage_header_prefix=baggage_header_prefix,
debug_id_header=debug_id_header,
),
Format.BINARY: BinaryCodec(),
ZipkinSpanFormat: ZipkinCodec(),
}
if extra_codecs:
self.codecs.update(extra_codecs)
self.tags = {
constants.JAEGER_VERSION_TAG_KEY: constants.JAEGER_CLIENT_VERSION,
}
if tags:
self.tags.update(tags)
if self.tags.get(constants.JAEGER_IP_TAG_KEY) is None:
self.tags[constants.JAEGER_IP_TAG_KEY] = local_ip()
if self.tags.get(constants.JAEGER_HOSTNAME_TAG_KEY) is None:
try:
hostname = socket.gethostname()
self.tags[constants.JAEGER_HOSTNAME_TAG_KEY] = hostname
except socket.error:
logger.exception('Unable to determine host name')
self.throttler = throttler
if self.throttler:
client_id = random.randint(0, sys.maxsize)
self.throttler._set_client_id(client_id)
self.tags[constants.CLIENT_UUID_TAG_KEY] = client_id
self.reporter.set_process(
service_name=self.service_name,
tags=self.tags,
max_length=self.max_tag_value_length,
)
super(Tracer, self).__init__(
scope_manager=scope_manager or ThreadLocalScopeManager()
)
def __init__(self, service_name, port, sample_rate, transport_handler=None, scope_manager=None):
super().__init__(service_name, scope_manager=scope_manager or ThreadLocalScopeManager())
self._port = port
self._sample_rate = sample_rate
self._transport_handler = transport_handler or queued_transport
def test_get_context_provider_for_scope_manager_thread(self):
scope_manager = ThreadLocalScopeManager()
ctx_prov = get_context_provider_for_scope_manager(scope_manager)
assert isinstance(ctx_prov, ddtrace.provider.DefaultContextProvider)
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
from __future__ import absolute_import
from mock import patch
import opentracing
from opentracing.scope_managers import ThreadLocalScopeManager
from opentracing_instrumentation.local_span import func_span
from opentracing_instrumentation.client_hooks._dbapi2 import db_span, _COMMIT
from opentracing_instrumentation.client_hooks._singleton import singleton
from opentracing_instrumentation import span_in_context
@patch('opentracing.tracer', new=opentracing.Tracer(ThreadLocalScopeManager()))
def test_func_span_without_parent():
with func_span('test', require_active_trace=False) as span:
assert span is not None
with func_span('test', require_active_trace=True) as span:
assert span is None
def test_func_span():
tracer = opentracing.tracer
span = tracer.start_span(operation_name='parent')
with span_in_context(span=span):
with func_span('test') as child_span:
assert span is child_span
with func_span('test', tags={'x': 'y'}) as child_span:
assert span is child_span