def __init__(self,
transport_handler,
queue_capacity=100,
batch_size=10,
flush_interval=DEFAULT_FLUSH_INTERVAL,
io_loop=None,
error_reporter=None,
metrics_factory=None,
**kwargs):
"""
:param transport_handler: Callback function that takes a message
parameter and handles logging it
:param queue_capacity: how many spans we can hold in memory before
starting to drop spans
:param batch_size: how many spans we can submit at once to Collector
:param flush_interval: how often the auto-flush is called (in seconds)
:param io_loop: which IOLoop to use.
:param error_reporter:
:param metrics_factory: an instance of MetricsFactory class, or None.
:param kwargs:
'logger'
:return:
"""
from threading import Lock
self.transport_handler = transport_handler
self.queue_capacity = queue_capacity
self.batch_size = batch_size
self.metrics_factory = metrics_factory or \
LegacyMetricsFactory(Metrics())
self.metrics = ReporterMetrics(self.metrics_factory)
self.error_reporter = error_reporter or ErrorReporter(Metrics())
self.logger = kwargs.get('logger', default_logger)
if queue_capacity < batch_size:
raise ValueError('Queue capacity cannot be less than batch size')
self.io_loop = io_loop
if self.io_loop is None:
self.logger.error('Zipkin Reporter has no IOLoop')
elif not six.callable(self.transport_handler):
self.logger.error('Zipkin Reporter has no transport handler')
else:
self.queue = tornado.queues.Queue(maxsize=queue_capacity)
self.stop = object()
self.stopped = False
self.stop_lock = Lock()
self.flush_interval = flush_interval or None
self.io_loop.spawn_callback(self._consume_queue)
def test_submit_failure(self):
reporter, sender = self._new_reporter(batch_size=1)
reporter.error_reporter = ErrorReporter(metrics=reporter.metrics,
logger=logging.getLogger())
assert Metrics.REPORTER_FAILURE not in reporter.metrics.counters
# simulate exception in send
reporter._send = mock.MagicMock(side_effect=ValueError())
reporter.report_span(self._new_span('1'))
yield self._wait_for(
lambda: Metrics.REPORTER_FAILURE in reporter.metrics.counters)
assert 1 == reporter.metrics.counters.get(Metrics.REPORTER_FAILURE)
# silly test, for code coverage only
yield reporter._submit([])
def test_submit_failure(self):
reporter, sender = self._new_reporter(batch_size=1)
reporter.error_reporter = ErrorReporter(metrics=Metrics(),
logger=logging.getLogger())
reporter_failure_key = 'jaeger:reporter_spans.result_err'
assert reporter_failure_key not in reporter.metrics_factory.counters
# simulate exception in send
reporter._send = mock.MagicMock(side_effect=ValueError())
reporter.report_span(self._new_span('1'))
yield self._wait_for(
lambda: reporter_failure_key in reporter.metrics_factory.counters)
assert 1 == reporter.metrics_factory.counters.get(reporter_failure_key)
# silly test, for code coverage only
yield reporter._submit([])