def test_tracing(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False, prefix='Prod007')
mock_perform_req.return_value = {'hits': []}
main_span = DummySpan()
set_active_span(main_span)
enable_tracing()
body = {"any": "data", "timestamp": datetime.datetime.now()}
res = self.es.index(index='test-index', doc_type='tweet', id=1,
body=body, params={'refresh': True})
self.assertEqual(mock_perform_req.return_value, res)
self.assertEqual(1, len(self.tracer.spans))
self.assertEqual(self.tracer.spans[0].operation_name, 'Prod007/test-index/tweet/1')
self.assertEqual(self.tracer.spans[0].is_finished, True)
self.assertEqual(self.tracer.spans[0].child_of, main_span)
self.assertEqual(self.tracer.spans[0].tags, {
'component': 'elasticsearch-py',
'db.type': 'elasticsearch',
'db.statement': body,
'span.kind': 'client',
'elasticsearch.url': '/test-index/tweet/1',
'elasticsearch.method': 'PUT',
'elasticsearch.params': {'refresh': True},
})
def test_trace_none(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False)
set_active_span(DummySpan())
self.es.get(index='test-index', doc_type='tweet', id=3)
self.assertEqual(0, len(self.tracer.spans))
def test_trace_bool_payload(self, mock_perform_req):
init_tracing(self.tracer)
# Some operations, as creating an index, return a bool value.
mock_perform_req.return_value = False
mapping = "{'properties': {'body': {}}}"
res = self.es.indices.create('test-index', body=mapping)
self.assertFalse(res)
self.assertEqual(1, len(self.tracer.spans))
self.assertEqual(self.tracer.spans[0].is_finished, True)
def test_disable_tracing(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False)
enable_tracing()
disable_tracing()
self.assertEqual(0, len(self.tracer.spans))
self.es.get(index='test-index', doc_type='tweet', id=1)
self.assertEqual(0, len(self.tracer.spans))
disable_tracing() # shouldn't cause a problem
def test_clear_span(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False)
enable_tracing()
set_active_span(DummySpan())
clear_active_span()
self.es.get(index='test-index', doc_type='tweet', id=1)
self.assertEqual(1, len(self.tracer.spans))
self.assertEqual(None, self.tracer.spans[0].child_of)
def test_trace_all_requests_span(self, mock_perform_req):
init_tracing(self.tracer)
main_span = DummySpan()
set_active_span(main_span)
for i in range(3):
self.es.get(index='test-index', doc_type='tweet', id=i)
self.assertEqual(3, len(self.tracer.spans))
self.assertTrue(all(map(lambda x: x.is_finished, self.tracer.spans)))
self.assertTrue(all(map(lambda x: x.child_of == main_span, self.tracer.spans)))
def test_trace_result_tags(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False)
mock_perform_req.return_value = {
'found': False,
'timed_out': True,
'took': 7
}
enable_tracing()
self.es.get(index='test-index', doc_type='tweet', id=1)
self.assertEqual(1, len(self.tracer.spans))
self.assertTrue(all(map(lambda x: x.is_finished, self.tracer.spans)))
self.assertEqual('False', self.tracer.spans[0].tags['elasticsearch.found'])
self.assertEqual('True', self.tracer.spans[0].tags['elasticsearch.timed_out'])
self.assertEqual('7', self.tracer.spans[0].tags['elasticsearch.took'])
def test_trace_all_requests(self, mock_perform_req):
init_tracing(self.tracer)
for i in range(3):
self.es.get(index='test-index', doc_type='tweet', id=i)
self.assertEqual(3, len(self.tracer.spans))
self.assertTrue(all(map(lambda x: x.is_finished, self.tracer.spans)))
enable_tracing()
disable_tracing() # Shouldnt prevent further tracing
self.es.get(index='test-index', doc_type='tweet', id=4)
self.assertEqual(4, len(self.tracer.spans))
self.assertTrue(all(map(lambda x: x.is_finished, self.tracer.spans)))
self.assertTrue(all(map(lambda x: x.child_of is None, self.tracer.spans)))
def test_trace_after_error(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False)
enable_tracing()
mock_perform_req.side_effect = RuntimeError()
try:
self.es.get(index='test-index', doc_type='tweet', id=1)
except RuntimeError as exc:
pass
self.tracer.clear()
# Should not cause any further tracing
mock_perform_req.side_effect = None
self.es.get(index='test-index', doc_type='tweet', id=1)
self.assertEqual(0, len(self.tracer.spans))
def test_disable_tracing_span(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False)
main_span = DummySpan()
set_active_span(main_span)
# Make sure the active span was preserved
enable_tracing()
disable_tracing()
self.assertEqual(main_span, get_active_span())
# Make sure it was preserved, by tracing.
enable_tracing()
self.es.get(index='test-index', doc_type='tweet', id=1)
self.assertEqual(1, len(self.tracer.spans))
self.assertEqual(main_span, self.tracer.spans[0].child_of)
def test_trace_error(self, mock_perform_req):
init_tracing(self.tracer, trace_all_requests=False)
main_span = DummySpan()
set_active_span(main_span)
enable_tracing()
mock_perform_req.side_effect = RuntimeError()
try:
self.es.get(index='test-index', doc_type='tweet', id=1)
except RuntimeError as exc:
catched_exc = exc
self.assertEqual(1, len(self.tracer.spans))
self.assertEqual(True, self.tracer.spans[0].is_finished)
self.assertEqual(main_span, self.tracer.spans[0].child_of)
self.assertEqual('true', self.tracer.spans[0].tags['error'])
self.assertEqual(catched_exc, self.tracer.spans[0].tags['error.object'])
def instrument(tracer=None):
"""
Elasticsearch auto-instrumentation works by hooking a __new__ proxy for a TracingTransport
instance upon elasticsearch.transports.Transport initialization to trigger proper inheritance.
"""
elasticsearch = utils.get_module('elasticsearch')
if utils.is_instrumented(elasticsearch):
return
from elasticsearch_opentracing import init_tracing, TracingTransport
_tracer = tracer or config.tracer or opentracing.tracer
init_tracing(_tracer, trace_all_requests=True, prefix=config.prefix)
_transport_new[0] = elasticsearch.transport.Transport.__new__
_tracing_transport_new[0] = TracingTransport.__new__
TracingTransport.__new__ = tracing_transport_new.__get__(TracingTransport)
elasticsearch.transport.Transport.__new__ = transport_new.__get__(
elasticsearch.transport.Transport)
utils.mark_instrumented(elasticsearch)
def test_multithreading(self, mock_perform_req):
init_tracing(self.tracer)
ev = threading.Event()
# 1. Start tracing from thread-1; make thread-2 wait
# 2. Trace something from thread-2, make thread-1 before finishing.
# 3. Check the spans got different parents, and are in the expected order.
def target1():
set_active_span(DummySpan())
enable_tracing()
self.es.get(index='test-index', doc_type='tweet', id=1)
ev.set()
ev.wait()
disable_tracing()
def target2():
ev.wait()
enable_tracing()
self.es.get(index='test-index', doc_type='tweet', id=2)
ev.set()
disable_tracing()
t1 = threading.Thread(target=target1)
t2 = threading.Thread(target=target2)
t1.start()
t2.start()
t1.join()
t2.join()
self.assertEqual(2, len(self.tracer.spans))
self.assertTrue(all(map(lambda x: x.is_finished, self.tracer.spans)))
self.assertEqual([False, True], map(lambda x: x.child_of is None, self.tracer.spans))
#!/usr/bin/env python3
# https://github.com/opentracing-contrib/python-elasticsearch
import elasticsearch_opentracing
elasticsearch_opentracing.init_tracing(
tracer) # An OpenTracing compatible tracer.
es = Elasticsearch(transport_class=elasticsearch_opentracing.TracingTransport)
elasticsearch_opentracing.set_active_span(main_span) # Optional.
es.index(index='test-index',
doc_type='tweet',
id=99,
body={
'author': 'linus',
'text': 'Hello there',
'timestamp': datetime.now(),
})
res = es.get(index='test-index', doc_type='tweet', id=99)
elasticsearch_opentracing.clear_active_span()
def test_init_trace_prefix(self):
init_tracing(DummyTracer(), prefix='Prod007')
self.assertEqual('Prod007', elasticsearch_opentracing.g_trace_prefix)
init_tracing(DummyTracer(), prefix='')
self.assertEqual('', elasticsearch_opentracing.g_trace_prefix)
def test_init(self):
tracer = DummyTracer()
init_tracing(tracer)
self.assertEqual(tracer, elasticsearch_opentracing.g_tracer)
self.assertEqual(True, elasticsearch_opentracing.g_trace_all_requests)
self.assertEqual('Elasticsearch', elasticsearch_opentracing.g_trace_prefix)
tracer = lightstep.Tracer(component_name='elasticsearch-map',
access_token='{your_lightstep_token}')
class Article(DocType):
title = Text(analyzer='snowball', fields={'raw': Keyword()})
body = Text(analyzer='snowball')
tags = Keyword()
published_from = Date()
class Meta:
index = 'test-index'
if __name__ == '__main__':
elasticsearch_opentracing.init_tracing(tracer)
connections.create_connection(
hosts=['127.0.0.1'],
transport_class=elasticsearch_opentracing.TracingTransport)
Article.init()
# Have a master span only for the ingestion/get.
with tracer.start_span('main span') as span:
elasticsearch_opentracing.set_active_span(span)
article = Article(meta={'id': 7},
title='About searching',
body='A few words here, a few words there',
tags=['elastic', 'search'],
from datetime import datetime
from elasticsearch import Elasticsearch
import lightstep
import elasticsearch_opentracing
tracer = lightstep.Tracer(component_name='elasticsearch-explicit',
access_token='{your_lightstep_token}')
if __name__ == '__main__':
elasticsearch_opentracing.init_tracing(tracer, trace_all_requests=False)
es = Elasticsearch(
'127.0.0.1',
transport_class=elasticsearch_opentracing.TracingTransport)
# We want to trace only the creation of the document, not the
# index creation not checking the document was actually created.
with tracer.start_span('main span') as main_span:
elasticsearch_opentracing.set_active_span(main_span)
es.indices.create('test-index', ignore=400)
doc = {
'author': 'john',
'text': 'Find me if you can',
'timestamp': datetime.now(),
}
elasticsearch_opentracing.enable_tracing()
def test_init_trace_all_requests(self):
init_tracing(DummyTracer(), trace_all_requests=False)
self.assertEqual(False, elasticsearch_opentracing.g_trace_all_requests)
init_tracing(DummyTracer(), trace_all_requests=True)
self.assertEqual(True, elasticsearch_opentracing.g_trace_all_requests)