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)
