class MockTelemetrySender(channel.TelemetryChannel().sender.__class__): def __init__(self): self.data = None self.send_buffer_size = 1 def send(self, envelope): self.data = envelope[0]
def setup_logging(ikey): telemetry_channel = channel.TelemetryChannel() telemetry_channel.context.application.ver = __version__ telemetry_channel.context.properties['worker.id'] = str(uuid.uuid4()) handler = LoggingHandler(ikey, telemetry_channel=telemetry_channel) logging.basicConfig(handlers=[handler], format='%(levelname)s: %(message)s', level=logging.DEBUG)
def test_construct_with_context_and_sender(self): mock_sender = MockTelemetrySender() queue = channel.SynchronousQueue(mock_sender) context_global = channel.TelemetryContext() context_global.device.id = "global" actual = channel.TelemetryChannel(context_global, queue) actual.write(channel.contracts.MessageData()) actual.flush() self.assertIsNotNone(mock_sender.data) self.assertEqual("global", mock_sender.data.tags["ai.device.id"])
def test_track_exception_works_as_expected(self): def process(data, context): data.properties["NEW_PROP"] = "MYPROP" context.user.id = "BOTUSER" context.session.id = "BOTSESSION" return True sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient( '99999999-9999-9999-9999-999999999999', channel.TelemetryChannel(context=None, queue=queue)) client.add_telemetry_processor(process) client.context.device = None try: raise Exception("blah") except Exception as e: client.track_exception(*sys.exc_info(), properties={}, measurements={'x': 42}) client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Exception", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.device.id": "DEVICE_ID_PLACEHOLDER", "ai.device.locale": "DEVICE_LOCALE_PLACEHOLDER", "ai.device.osVersion": "DEVICE_OS_VERSION_PLACEHOLDER", "ai.device.type": "DEVICE_TYPE_PLACEHOLDER", "ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER", "ai.session.id": "BOTSESSION", "ai.user.id": "BOTUSER"}, "data": {"baseType": "ExceptionData", "baseData": {"ver": 2, "exceptions": [{"id": 1, "outerId": 0, "typeName": "Exception", "message": "blah", "hasFullStack": true, "parsedStack": [{"level": 0, "method": "test_track_exception_works_as_expected", "assembly": "Unknown", "fileName": "TestTelemetryProcessor.py", "line": 0}]}], "properties": {"NEW_PROP": "MYPROP"}, "measurements": {"x": 42}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' sender.data.tags['ai.device.id'] = "DEVICE_ID_PLACEHOLDER" sender.data.tags['ai.device.locale'] = "DEVICE_LOCALE_PLACEHOLDER" sender.data.tags[ 'ai.device.osVersion'] = "DEVICE_OS_VERSION_PLACEHOLDER" sender.data.tags['ai.device.type'] = "DEVICE_TYPE_PLACEHOLDER" for item in sender.data.data.base_data.exceptions: for frame in item.parsed_stack: frame.file_name = os.path.basename(frame.file_name) frame.line = 0 actual = json.dumps(sender.data.write()) self.maxDiff = None self.assertEqual(expected, actual) try: raise Exception("blah") except Exception as e: client.track_exception() client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Exception", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.device.id": "DEVICE_ID_PLACEHOLDER", "ai.device.locale": "DEVICE_LOCALE_PLACEHOLDER", "ai.device.osVersion": "DEVICE_OS_VERSION_PLACEHOLDER", "ai.device.type": "DEVICE_TYPE_PLACEHOLDER", "ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER", "ai.session.id": "BOTSESSION", "ai.user.id": "BOTUSER"}, "data": {"baseType": "ExceptionData", "baseData": {"ver": 2, "exceptions": [{"id": 1, "outerId": 0, "typeName": "Exception", "message": "blah", "hasFullStack": true, "parsedStack": [{"level": 0, "method": "test_track_exception_works_as_expected", "assembly": "Unknown", "fileName": "TestTelemetryProcessor.py", "line": 0}]}], "properties": {"NEW_PROP": "MYPROP"}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' sender.data.tags['ai.device.id'] = "DEVICE_ID_PLACEHOLDER" sender.data.tags['ai.device.locale'] = "DEVICE_LOCALE_PLACEHOLDER" sender.data.tags[ 'ai.device.osVersion'] = "DEVICE_OS_VERSION_PLACEHOLDER" sender.data.tags['ai.device.type'] = "DEVICE_TYPE_PLACEHOLDER" for item in sender.data.data.base_data.exceptions: for frame in item.parsed_stack: frame.file_name = os.path.basename(frame.file_name) frame.line = 0 actual = json.dumps(sender.data.write()) self.assertEqual(expected, actual)
def test_write_transfers_local_convext_over_global_context(self): mock_sender = MockTelemetrySender() queue = channel.SynchronousQueue(mock_sender) context_global = channel.TelemetryContext() context_global.device.id = "global" context_local = channel.TelemetryContext() context_local.device.id = "local" actual = channel.TelemetryChannel(context_global, queue) actual.write(channel.contracts.MessageData(), context_local) actual.flush() self.assertIsNotNone(mock_sender.data) self.assertEqual("local", mock_sender.data.tags["ai.device.id"])
def test_track_pageview_works_as_expected(self): sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient('99999999-9999-9999-9999-999999999999', channel.TelemetryChannel(context=None, queue=queue)) client.context.device = None client.track_pageview('test', 'http://tempuri.org', 13, { 'foo': 'bar' }, { 'x': 42 }) client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.PageView", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "PageViewData", "baseData": {"ver": 2, "url": "http://tempuri.org", "name": "test", "duration": 13, "properties": {"foo": "bar"}, "measurements": {"x": 42}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' actual = json.dumps(sender.data.write()) self.maxDiff = None self.assertEqual(expected, actual)
def test_track_trace_works_as_expected(self): sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient('99999999-9999-9999-9999-999999999999', channel.TelemetryChannel(context=None, queue=queue)) client.context.device = None client.track_trace('test', { 'foo': 'bar' }, severity='WARNING') client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Message", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "MessageData", "baseData": {"ver": 2, "message": "test", "severityLevel": 2, "properties": {"foo": "bar"}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' actual = json.dumps(sender.data.write()) self.maxDiff = None self.assertEqual(expected, actual)
def test_track_metric_works_as_expected(self): sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient('99999999-9999-9999-9999-999999999999', channel.TelemetryChannel(context=None, queue=queue)) client.context.device = None client.track_metric('metric', 42, channel.contracts.DataPointType.aggregation, 13, 1, 123, 111, {'foo': 'bar'}) client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Metric", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "MetricData", "baseData": {"ver": 2, "metrics": [{"name": "metric", "kind": 1, "value": 42, "count": 13, "min": 1, "max": 123, "stdDev": 111}], "properties": {"foo": "bar"}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' actual = json.dumps(sender.data.write()) self.maxDiff = None self.assertEqual(expected, actual)
def test_track_event_with_common_processor_two_clients(self): def process(data, context): data.properties["NEW_PROP"] = "MYPROP" context.user.id = "BOTUSER" context.session.id = "BOTSESSION" return True key = '99999999-9999-9999-9999-999999999999' sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) chan = channel.TelemetryChannel(queue=queue) chan.context.properties['foo'] = 'bar' client1 = TelemetryClient(key, chan) client1.add_telemetry_processor(process) client1.context.device = None client1.context.properties['x'] = 42 client2 = TelemetryClient(key, chan) client2.add_telemetry_processor(process) client2.context.device = None client2.context.properties['x'] = 84 client1.track_event('test 1') client1.flush() sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' sender.data.tags['ai.device.id'] = "DEVICE_ID_PLACEHOLDER" sender.data.tags['ai.device.locale'] = "DEVICE_LOCALE_PLACEHOLDER" sender.data.tags[ 'ai.device.osVersion'] = "DEVICE_OS_VERSION_PLACEHOLDER" sender.data.tags['ai.device.type'] = "DEVICE_TYPE_PLACEHOLDER" actual = json.dumps(sender.data.write()) expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Event", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.device.id": "DEVICE_ID_PLACEHOLDER", "ai.device.locale": "DEVICE_LOCALE_PLACEHOLDER", "ai.device.osVersion": "DEVICE_OS_VERSION_PLACEHOLDER", "ai.device.type": "DEVICE_TYPE_PLACEHOLDER", "ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER", "ai.session.id": "BOTSESSION", "ai.user.id": "BOTUSER"}, "data": {"baseType": "EventData", "baseData": {"ver": 2, "name": "test 1", "properties": {"NEW_PROP": "MYPROP", "foo": "bar", "x": 42}}}}' self.maxDiff = None self.assertEqual(expected, actual) client2.track_event('test 2') client2.flush() sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' sender.data.tags['ai.device.id'] = "DEVICE_ID_PLACEHOLDER" sender.data.tags['ai.device.locale'] = "DEVICE_LOCALE_PLACEHOLDER" sender.data.tags[ 'ai.device.osVersion'] = "DEVICE_OS_VERSION_PLACEHOLDER" sender.data.tags['ai.device.type'] = "DEVICE_TYPE_PLACEHOLDER" actual = json.dumps(sender.data.write()) expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Event", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.device.id": "DEVICE_ID_PLACEHOLDER", "ai.device.locale": "DEVICE_LOCALE_PLACEHOLDER", "ai.device.osVersion": "DEVICE_OS_VERSION_PLACEHOLDER", "ai.device.type": "DEVICE_TYPE_PLACEHOLDER", "ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER", "ai.session.id": "BOTSESSION", "ai.user.id": "BOTUSER"}, "data": {"baseType": "EventData", "baseData": {"ver": 2, "name": "test 2", "properties": {"NEW_PROP": "MYPROP", "foo": "bar", "x": 84}}}}' self.assertEqual(expected, actual)
def test_track_event_processor_filtered(self): def process(data, context): return False # Filter the event sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient( '99999999-9999-9999-9999-999999999999', channel.TelemetryChannel(context=None, queue=queue)) client.add_telemetry_processor(process) client.context.device = None client.track_event('test', {'foo': 'bar'}, {'x': 42}) client.flush() self.assertEqual(None, sender.data)
def test_track_request_works_as_expected(self): sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient(channel.TelemetryChannel(context=None, queue=queue)) client.context.instrumentation_key = '99999999-9999-9999-9999-999999999999' client.context.device = None client.track_request('test', 'http://tempuri.org', True, 'START_TIME', 13, '42', 'OPTIONS', { 'foo': 'bar' }, { 'x': 42 }) client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Request", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "RequestData", "baseData": {"ver": 2, "id": "ID_PLACEHOLDER", "name": "test", "startTime": "START_TIME", "duration": "00:00:00.013", "responseCode": "42", "success": true, "httpMethod": "OPTIONS", "url": "http://tempuri.org", "properties": {"foo": "bar"}, "measurements": {"x": 42}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' sender.data.data.base_data.id = 'ID_PLACEHOLDER' actual = json.dumps(sender.data.write()) self.maxDiff = None self.assertEqual(expected, actual)
def test_enable(self): original = sys.excepthook sys.excepthook = mock_excepthook sender = MockSynchronousSender() queue = channel.SynchronousQueue(sender) telemetry_channel = channel.TelemetryChannel(None, queue) exceptions.enable('foo', telemetry_channel=telemetry_channel) try: raise Exception('Boom') except: sys.excepthook(*sys.exc_info()) sys.excepthook = original data = sender.data[0][0] self.assertIsNotNone(data) self.assertEqual('foo', data.ikey) self.assertEqual('Microsoft.ApplicationInsights.Exception', data.name)
def __init__(self, instrumentation_key, telemetry_channel=None): """Initializes a new instance of the class. Args: instrumentation_key (str). the instrumentation key to use for this telemetry client.\n telemetry_channel (:class:`channel.TelemetryChannel`). the optional telemetry channel to be used instead of constructing a default one. """ if instrumentation_key: if isinstance(instrumentation_key, channel.TelemetryChannel): telemetry_channel = instrumentation_key instrumentation_key = None else: raise Exception('Instrumentation key was required but not provided') self._context = channel.TelemetryContext() self._context.instrumentation_key = instrumentation_key self._channel = telemetry_channel or channel.TelemetryChannel()
def test_track_event_works_as_expected(self): sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient('99999999-9999-9999-9999-999999999999', channel.TelemetryChannel(context=None, queue=queue)) client.context.device = None client.track_event('test', { 'foo': 'bar' }, { 'x': 42 }) client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Event", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.device.id": "DEVICE_ID_PLACEHOLDER", "ai.device.locale": "DEVICE_LOCALE_PLACEHOLDER", "ai.device.osVersion": "DEVICE_OS_VERSION_PLACEHOLDER", "ai.device.type": "DEVICE_TYPE_PLACEHOLDER", "ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "EventData", "baseData": {"ver": 2, "name": "test", "properties": {"foo": "bar"}, "measurements": {"x": 42}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' sender.data.tags['ai.device.id'] = "DEVICE_ID_PLACEHOLDER" sender.data.tags['ai.device.locale'] = "DEVICE_LOCALE_PLACEHOLDER" sender.data.tags['ai.device.osVersion'] = "DEVICE_OS_VERSION_PLACEHOLDER" sender.data.tags['ai.device.type'] = "DEVICE_TYPE_PLACEHOLDER" actual = json.dumps(sender.data.write()) self.maxDiff = None self.assertEqual(expected, actual)
def test_track_dependency_works_as_expected(self): sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient(channel.TelemetryChannel(context=None, queue=queue)) client.context.instrumentation_key = '99999999-9999-9999-9999-999999999999' client.context.device = None client.track_dependency('test', 'COMMAND_PLACEHOLDER', 'HTTP', 'localhost', 13, True, 200, { 'foo': 'bar' }, { 'x': 42 }, 'ID_PLACEHOLDER') client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.RemoteDependency", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.device.id": "DEVICE_ID_PLACEHOLDER", "ai.device.locale": "DEVICE_LOCALE_PLACEHOLDER", "ai.device.osVersion": "DEVICE_OS_VERSION_PLACEHOLDER", "ai.device.type": "DEVICE_TYPE_PLACEHOLDER", "ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "RemoteDependencyData", "baseData": {"ver": 2, "name": "test", "id": "ID_PLACEHOLDER", "resultCode": "200", "duration": "00:00:00.013", "success": true, "data": "COMMAND_PLACEHOLDER", "target": "localhost", "type": "HTTP", "properties": {"foo": "bar"}, "measurements": {"x": 42}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' sender.data.tags['ai.device.id'] = "DEVICE_ID_PLACEHOLDER" sender.data.tags['ai.device.locale'] = "DEVICE_LOCALE_PLACEHOLDER" sender.data.tags['ai.device.osVersion'] = "DEVICE_OS_VERSION_PLACEHOLDER" sender.data.tags['ai.device.type'] = "DEVICE_TYPE_PLACEHOLDER" actual = json.dumps(sender.data.write()) self.maxDiff = None self.assertEqual(expected, actual)
def test_enable(self): original = sys.excepthook sys.excepthook = mock_excepthook sender = MockSynchronousSender() queue = channel.SynchronousQueue(sender) telemetry_channel = channel.TelemetryChannel(None, queue) telemetry_channel.context.properties["foo"] = "bar" telemetry_channel.context.operation.id = 1001 exceptions.enable('foo', telemetry_channel=telemetry_channel) try: raise Exception('Boom') except: sys.excepthook(*sys.exc_info()) sys.excepthook = original data = sender.data[0][0] self.assertIsNotNone(data) self.assertEqual('foo', data.ikey) self.assertEqual('Microsoft.ApplicationInsights.Exception', data.name) self.assertEqual('bar', data.data.base_data.properties['foo']) self.assertEqual(1001, data.tags.get('ai.operation.id'))
def _setup_telemetry_channel(self): """Create telemetry_channel object. Instantiates a telemetry channel that collects unhandled exceptions. Return: telemetry_channel """ from applicationinsights.exceptions import enable from applicationinsights import channel # set up channel with context telemetry_channel = channel.TelemetryChannel() telemetry_channel.context.application.ver = get_version() # set up exception capture telemetry_channel.context.properties['capture'] = 'exceptions' enable(APP_INSIGHTS_KEY, telemetry_channel=telemetry_channel) return telemetry_channel
def create_telemetrie_client(): key = get_instrumentation_key() #https://microsoft.github.io/ApplicationInsights-Python/ queue = AsynchronousQueue(AsynchronousSender()) telemetrie_channel = channel.TelemetryChannel(None, queue) telemetrie = TelemetryClient(key, telemetry_channel = telemetrie_channel) # flush telemetry if we have 10 or more telemetry items in our queue telemetrie.channel.queue.max_queue_length = 10 # send telemetry to the service in batches of 5 telemetrie.channel.sender.send_buffer_size = 1 # the background worker thread will be active for 5 seconds before it shuts down. if # during this time items are picked up from the queue, the timer is reset. telemetrie.channel.sender.send_time = 5 # the background worker thread will poll the queue every 0.5 seconds for new items telemetrie.channel.sender.send_interval = 0.5 telemetrie.context.operation.name = 'neural-image-tensorflow' return telemetrie
def test_enable_for_urllib2(self): import urllib2 sender = MockSynchronousSender() queue = channel.SynchronousQueue(sender) telemetry_channel = channel.TelemetryChannel(None, queue) telemetry_channel.context.properties["foo"] = "bar" telemetry_channel.context.operation.id = 1001 client.enable_for_urllib2('foo', telemetry_channel=telemetry_channel, always_flush=True) httpretty.register_uri(httpretty.GET, BASE_HTTP_URL, body='{"foo": "bar"}') httpretty.register_uri(httpretty.GET, BASE_HTTPS_URL, body='{"foo": "bar"}') for url in [BASE_HTTP_URL, BASE_HTTPS_URL]: response = urllib2.urlopen(url) self.assertEqual(200, response.code) self.assertEqual({"foo": "bar"}, json.loads(response.read().decode('utf-8'))) self.assertEqual(2, len(sender.data)) for i in range(2): data = sender.data[i][0] self.assertIsNotNone(data) self.assertEqual('foo', data.ikey) self.assertEqual('Microsoft.ApplicationInsights.RemoteDependency', data.name) self.assertEqual('bar', data.data.base_data.properties['foo']) self.assertEqual('GET /test', data.data.base_data.data) self.assertEqual('/test', data.data.base_data.target) self.assertEqual('200', data.data.base_data.result_code) self.assertEqual(1001, data.tags.get('ai.operation.id'))
def test_write_constructs_valid_envelope(self): mock_sender = MockTelemetrySender() queue = channel.SynchronousQueue(mock_sender) context_global = channel.TelemetryContext() context_global.instrumentation_key = "42" actual = channel.TelemetryChannel(context_global, queue) cases = [ channel.contracts.EventData(), channel.contracts.MetricData(), channel.contracts.MessageData(), channel.contracts.PageViewData(), channel.contracts.ExceptionData(), ] for item in cases: actual.write(item) actual.flush() self.assertIsNotNone(mock_sender.data) self.assertTrue( isinstance(mock_sender.data, channel.contracts.Envelope)) self.assertEqual(item.ENVELOPE_TYPE_NAME, mock_sender.data.name) self.assertIsNotNone(mock_sender.data.time) self.assertEqual("42", mock_sender.data.ikey) for key, value in context_global.device.write().items(): self.assertEqual(value, mock_sender.data.tags[key]) for key, value in context_global.application.write().items(): self.assertEqual(value, mock_sender.data.tags[key]) for key, value in context_global.user.write().items(): self.assertEqual(value, mock_sender.data.tags[key]) for key, value in context_global.session.write().items(): self.assertEqual(value, mock_sender.data.tags[key]) for key, value in context_global.location.write().items(): self.assertEqual(value, mock_sender.data.tags[key]) for key, value in context_global.operation.write().items(): self.assertEqual(value, mock_sender.data.tags[key]) self.assertIsNotNone(mock_sender.data.data) self.assertEqual(item.DATA_TYPE_NAME, mock_sender.data.data.base_type) self.assertEqual(item, mock_sender.data.data.base_data)
def test_track_exception_works_as_expected(self): sender = MockTelemetrySender() queue = channel.SynchronousQueue(sender) client = TelemetryClient( '99999999-9999-9999-9999-999999999999', channel.TelemetryChannel(context=None, queue=queue)) client.context.device = None try: raise Exception("blah") except Exception as e: client.track_exception(*sys.exc_info(), properties={}, measurements={'x': 42}) client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Exception", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "ExceptionData", "baseData": {"ver": 2, "exceptions": [{"id": 1, "outerId": 0, "typeName": "Exception", "message": "blah", "hasFullStack": true, "parsedStack": [{"level": 0, "method": "test_track_exception_works_as_expected", "assembly": "Unknown", "fileName": "TestTelemetryClient.py", "line": 0}]}], "measurements": {"x": 42}}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' for item in sender.data.data.base_data.exceptions: for frame in item.parsed_stack: frame.file_name = os.path.basename(frame.file_name) frame.line = 0 actual = json.dumps(sender.data.write()) self.assertEqual(expected, actual) try: raise Exception("blah") except Exception as e: client.track_exception() client.flush() expected = '{"ver": 1, "name": "Microsoft.ApplicationInsights.Exception", "time": "TIME_PLACEHOLDER", "sampleRate": 100.0, "iKey": "99999999-9999-9999-9999-999999999999", "tags": {"ai.internal.sdkVersion": "SDK_VERSION_PLACEHOLDER"}, "data": {"baseType": "ExceptionData", "baseData": {"ver": 2, "exceptions": [{"id": 1, "outerId": 0, "typeName": "Exception", "message": "blah", "hasFullStack": true, "parsedStack": [{"level": 0, "method": "test_track_exception_works_as_expected", "assembly": "Unknown", "fileName": "TestTelemetryClient.py", "line": 0}]}]}}}' sender.data.time = 'TIME_PLACEHOLDER' sender.data.tags['ai.internal.sdkVersion'] = 'SDK_VERSION_PLACEHOLDER' for item in sender.data.data.base_data.exceptions: for frame in item.parsed_stack: frame.file_name = os.path.basename(frame.file_name) frame.line = 0 actual = json.dumps(sender.data.write()) self.assertEqual(expected, actual)
import time from applicationinsights.exceptions import enable from applicationinsights import channel from applicationinsights.logging import LoggingHandler instrumentation_key = '<Instrumentation key>' #Enable unhandled exception logging enable(instrumentation_key) #setup other needed variables tc = TelemetryClient(instrumentation_key) tc.context.application.ver = '0.0.1' tc.context.device.id = 'Sample notebook' telemetry_channel = channel.TelemetryChannel() telemetry_channel.context.application.ver = '1.0.0' telemetry_channel.context.properties['application_name'] = 'sample_notebook' telemetry_channel.context.properties['application_id'] = sc.applicationId handler = LoggingHandler(instrumentation_key, telemetry_channel=telemetry_channel) handler.setLevel(logging.DEBUG) handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s')) logger = logging.getLogger('simple_logger') logger.setLevel(logging.INFO) logger.addHandler(handler) logger.info('Starting sample app ... ')
def test_construct(self): actual = channel.TelemetryChannel() self.assertIsNotNone(actual)
def test_channel_property_works_as_expected(self): expected = channel.TelemetryChannel() client = TelemetryClient('foo', expected) self.assertEqual(expected, client.channel)
def test_constructor_maintains_backwards_compatibility_when_specifying_only_telemetry_channel(self): expected = channel.TelemetryChannel() client = TelemetryClient(expected) self.assertEqual(expected, client.channel) self.assertIsNone(client.context.instrumentation_key)
def test_sender_works_as_expected(self): actual = channel.TelemetryChannel() self.assertIsNotNone(actual.sender)
def start_logger() -> None: """ Start logging of messages passed through the python logging module. This sets up logging to a time based logging. This means that all logging messages on or above ``filelogginglevel`` will be written to `pythonlog.log` All logging messages on or above ``consolelogginglevel`` will be written to stderr. ``filelogginglevel`` and ``consolelogginglevel`` are defined in the ``qcodesrc.json`` file. """ global console_handler global file_handler # set loggers to the supplied levels for name, level in qc.config.logger.logger_levels.items(): logging.getLogger(name).setLevel(level) root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) # remove previously set handlers for handler in (console_handler, file_handler): if handler is not None: handler.close() root_logger.removeHandler(handler) # add qcodes handlers # console console_handler = logging.StreamHandler() console_handler.setLevel(qc.config.logger.console_level) console_handler.setFormatter(get_formatter()) root_logger.addHandler(console_handler) # file filename = get_log_file_name() os.makedirs(os.path.dirname(filename), exist_ok=True) file_handler = logging.handlers.TimedRotatingFileHandler(filename, when='midnight') file_handler.setLevel(qc.config.logger.file_level) file_handler.setFormatter(get_formatter()) root_logger.addHandler(file_handler) # capture any warnings from the warnings module logging.captureWarnings(capture=True) if qc.config.telemetry.enabled: from applicationinsights import channel from applicationinsights.logging import enable # the telemetry_handler can be flushed global telemetry_handler loc = qc.config.GUID_components.location stat = qc.config.GUID_components.work_station sender = channel.AsynchronousSender() queue = channel.AsynchronousQueue(sender) appin_channel = channel.TelemetryChannel(context=None, queue=queue) appin_channel.context.user.id = f'{loc:02x}-{stat:06x}' # it is not completely clear which context fields get sent up. # Here we shuffle some info from one field to another. acc_name = appin_channel.context.device.id appin_channel.context.user.account_id = acc_name # note that the following function will simply silently fail if an # invalid instrumentation key is used. There is thus no exception to # catch telemetry_handler = enable(qc.config.telemetry.instrumentation_key, telemetry_channel=appin_channel) log.info("QCoDes logger setup completed") log_qcodes_versions(log) print(f'Qcodes Logfile : {filename}')
def test_flush_works_as_expected(self): queue = MockQueue() actual = channel.TelemetryChannel(None, queue) self.assertEqual(0, queue.flush_count) actual.flush() self.assertEqual(1, queue.flush_count)
def test_write_with_no_data_raises_exception(self): mock_sender = MockTelemetrySender() queue = channel.SynchronousQueue(mock_sender) actual = channel.TelemetryChannel(None, queue) self.assertRaises(Exception, actual.write, None)