def __init__(self, **kwargs):
if not 'diagnostic_opt_out' in kwargs:
kwargs['diagnostic_opt_out'] = True
if not 'sdk_key' in kwargs:
kwargs['sdk_key'] = 'SDK_KEY'
config = Config(**kwargs)
diagnostic_accumulator = _DiagnosticAccumulator(create_diagnostic_id(config))
DefaultEventProcessor.__init__(self, config, mock_http, diagnostic_accumulator = diagnostic_accumulator)
def test_diagnostic_accumulator():
test_config = Config(sdk_key="SDK_KEY")
diag_id = create_diagnostic_id(test_config)
diag_accum = _DiagnosticAccumulator(diag_id)
# Test default periodic event
def_diag_event = diag_accum.create_event_and_reset(0, 0)
assert len(def_diag_event) == 8
assert def_diag_event['kind'] == 'diagnostic'
assert def_diag_event['id'] == diag_id
assert def_diag_event['creationDate'] == diag_accum.data_since_date
assert def_diag_event['dataSinceDate']
assert def_diag_event['droppedEvents'] == 0
assert def_diag_event['deduplicatedUsers'] == 0
assert def_diag_event['eventsInLastBatch'] == 0
assert def_diag_event['streamInits'] == []
# Verify converts to json without failure
json.dumps(def_diag_event)
# Test periodic event after recording values
diag_accum.record_stream_init(100, 100, False)
diag_accum.record_stream_init(300, 200, True)
diag_accum.record_events_in_batch(10)
diag_accum.record_events_in_batch(50)
diag_event = diag_accum.create_event_and_reset(10, 15)
assert len(diag_event) == 8
assert diag_event['kind'] == 'diagnostic'
assert diag_event['id'] == diag_id
assert diag_event['creationDate'] == diag_accum.data_since_date
assert diag_event['dataSinceDate'] == def_diag_event['creationDate']
assert diag_event['droppedEvents'] == 10
assert diag_event['deduplicatedUsers'] == 15
assert diag_event['eventsInLastBatch'] == 50
assert diag_event['streamInits'] == [{
'timestamp': 100,
'durationMillis': 100,
'failed': False
}, {
'timestamp': 300,
'durationMillis': 200,
'failed': True
}]
json.dumps(diag_event)
reset_diag_event = diag_accum.create_event_and_reset(0, 0)
assert reset_diag_event['creationDate'] == diag_accum.data_since_date
assert reset_diag_event['dataSinceDate'] == diag_event['creationDate']
del reset_diag_event['creationDate']
del def_diag_event['creationDate']
del reset_diag_event['dataSinceDate']
del def_diag_event['dataSinceDate']
assert reset_diag_event == def_diag_event
def _set_event_processor(self, config):
if config.offline or not config.send_events:
self._event_processor = NullEventProcessor()
return None
if not config.event_processor_class:
diagnostic_id = create_diagnostic_id(config)
diagnostic_accumulator = None if config.diagnostic_opt_out else _DiagnosticAccumulator(
diagnostic_id)
self._event_processor = DefaultEventProcessor(
config, diagnostic_accumulator=diagnostic_accumulator)
return diagnostic_accumulator
self._event_processor = config.event_processor_class(config)
return None
def test_records_diagnostic_on_stream_init_success():
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
config = Config(sdk_key='sdk-key', stream_uri=server.uri)
server.for_path('/all', stream)
diag_accum = _DiagnosticAccumulator(1)
with StreamingUpdateProcessor(config, store, ready,
diag_accum) as sp:
sp.start()
ready.wait(start_wait)
recorded_inits = diag_accum.create_event_and_reset(
0, 0)['streamInits']
assert len(recorded_inits) == 1
assert recorded_inits[0]['failed'] is False
def test_records_diagnostic_on_stream_init_failure():
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
config = Config(sdk_key='sdk-key', stream_uri=server.uri)
server.setup_response('/all', 200, 'event:put\ndata: {\n\n',
response_headers)
diag_accum = _DiagnosticAccumulator(1)
with StreamingUpdateProcessor(config, None, store, ready,
diag_accum) as sp:
sp.start()
server.await_request()
server.await_request()
recorded_inits = diag_accum.create_event_and_reset(
0, 0)['streamInits']
assert recorded_inits[0]['failed'] is True
def test_records_diagnostic_on_stream_init_failure():
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
error_then_success = SequentialHandler(BasicResponse(503), stream)
config = Config(sdk_key='sdk-key',
stream_uri=server.uri,
initial_reconnect_delay=brief_delay)
server.for_path('/all', error_then_success)
diag_accum = _DiagnosticAccumulator(1)
with StreamingUpdateProcessor(config, store, ready,
diag_accum) as sp:
sp.start()
ready.wait(start_wait)
recorded_inits = diag_accum.create_event_and_reset(
0, 0)['streamInits']
assert len(recorded_inits) == 2
assert recorded_inits[0]['failed'] is True
assert recorded_inits[1]['failed'] is False
