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, "handledAt": "UserCode", "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, "handledAt": "UserCode", "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)
def intercept_excepthook(type, value, traceback):
client = TelemetryClient('temp_key', telemetry_channel)
for instrumentation_key in enabled_instrumentation_keys:
client.context.instrumentation_key = instrumentation_key
client.track_exception(type, value, traceback)
client.flush()
original_excepthook(type, value, traceback)
def intercept_excepthook(type, value, traceback):
client = TelemetryClient('temp_key', telemetry_channel)
for instrumentation_key in enabled_instrumentation_keys:
client.context.instrumentation_key = instrumentation_key
client.track_exception(type, value, traceback)
client.flush()
original_excepthook(type, value, traceback)
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, "handledAt": "UserCode", "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, "handledAt": "UserCode", "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)
def send_exceptions(client: TelemetryClient, num_exceptions: int):
for _ in range(num_exceptions):
exception = generate_exception()
# noinspection PyBroadException
try:
raise exception
except Exception:
client.track_exception()
LOG.info('sent exception %s', exception)
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 TrackEvent(File, Event, startTime,endTime):
try:
tc = TelemetryClient(Constants.AppInsight_Key)
host_name = socket.gethostname()
host_ip = socket.gethostbyname(host_name)
tc.track_event(Event, { 'Server': host_name , 'IP': host_ip ,'Event':Event,'File':File}, { 'TimeTaken': TimeDiffMinutes(startTime,endTime)})
tc.flush()
except:
tc.track_exception()
def TrackException(exp,File, Event, startTime,endTime):
try:
raise exp
except:
tc = TelemetryClient(Constants.AppInsight_Key)
host_name = socket.gethostname()
host_ip = socket.gethostbyname(host_name)
tc.track_exception(*sys.exc_info(), { 'Server': host_name , 'IP': host_ip ,'Event':Event,'File':File}, { 'TimeTaken': TimeDiffMinutes(startTime,endTime) })
tc.flush()
# Used for Debugging Purpose. Uncomment during debug and comment after fixing.
#if __name__ == '__main__': TestException()
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 get_instrumentation_key():
"""
Gets an application Insight's instrumentation key from Azure Key Vault.
"""
instrumentation_key = None
try:
instrumentation_key = get_key_vault_secret('APPINSIGHTSKEY')
except Exception as exception:
if instrumentation_key:
telemetry_client = TelemetryClient(instrumentation_key)
telemetry_client.track_exception()
return instrumentation_key
class AppInsights(object):
"""This class represents a Flask extension that enables request telemetry,
trace logging and exception logging for a Flask application. The telemetry
will be sent to Application Insights service using the supplied
instrumentation key.
The following Flask config variables can be used to configure the extension:
- Set ``APPINSIGHTS_INSTRUMENTATIONKEY`` to a string to provide the
instrumentation key to send telemetry to application insights.
Alternatively, this value can also be provided via an environment variable
of the same name.
- Set ``APPINSIGHTS_ENDPOINT_URI`` to a string to customize the telemetry
endpoint to which Application Insights will send the telemetry.
- Set ``APPINSIGHTS_DISABLE_REQUEST_LOGGING`` to ``False`` to disable
logging of Flask requests to Application Insights.
- Set ``APPINSIGHTS_DISABLE_TRACE_LOGGING`` to ``False`` to disable logging
of all log traces to Application Insights.
- Set ``APPINSIGHTS_DISABLE_EXCEPTION_LOGGING`` to ``False`` to disable
logging of all exceptions to Application Insights.
.. code:: python
from flask import Flask
from ai4e_app_insights import AppInsights
# instantiate the Flask application
app = Flask(__name__)
app.config['APPINSIGHTS_INSTRUMENTATIONKEY'] = '<YOUR INSTRUMENTATION KEY GOES HERE>'
# log requests, traces and exceptions to the Application Insights service
appinsights = AppInsights(app)
# define a simple route
@app.route('/')
def hello_world():
return 'Hello World!'
# run the application
if __name__ == '__main__':
app.run()
"""
def __init__(self, app=None, context=None):
"""
Initialize a new instance of the extension.
Args:
app (flask.Flask). the Flask application for which to initialize the extension.
"""
socket.setdefaulttimeout(30)
self._appinsights_key = None
self._endpoint_uri = None
self._channel = None
self._requests_middleware = None
self._trace_log_handler_grantee = None
self._trace_log_handler_ai4e = None
self._exception_telemetry_client_grantee = None
self._exception_telemetry_client_ai4e = None
if app:
self.init_app(app, context)
def init_app(self, app, context):
"""
Initializes the extension for the provided Flask application.
Args:
app (flask.Flask). the Flask application for which to initialize the extension.
"""
print("Starting application insights module.")
self._appinsights_key = app.config.get(
APPINSIGHTS_INSTRUMENTATIONKEY) or getenv(
APPINSIGHTS_INSTRUMENTATIONKEY)
if self._appinsights_key and len(self._appinsights_key.strip()) > 0:
self._appinsights_key = self._appinsights_key.strip()
else:
self._appinsights_key = None
# Set the application insights key for production use.
if self._appinsights_key:
print("Application insights key set.")
self._endpoint_uri = app.config.get(CONF_ENDPOINT_URI)
if self._endpoint_uri:
sender = AsynchronousSender(self._endpoint_uri)
else:
sender = AsynchronousSender()
queue = AsynchronousQueue(sender)
if not context:
context = AI4ETelemetryContext()
self._channel = TelemetryChannel(context, queue)
self._init_request_logging(app)
self._init_trace_logging(app)
self._init_exception_logging(app)
def _init_request_logging(self, app):
"""
Sets up request logging unless ``APPINSIGHTS_DISABLE_REQUEST_LOGGING``
is set in the Flask config.
Args:
app (flask.Flask). the Flask application for which to initialize the extension.
"""
enabled = not app.config.get(CONF_DISABLE_REQUEST_LOGGING, False)
if not enabled:
return
wsgi_key = self._appinsights_key
self._requests_middleware = WSGIApplication(
wsgi_key, app.wsgi_app, telemetry_channel=self._channel)
app.wsgi_app = self._requests_middleware
def _init_trace_logging(self, app):
"""
Sets up trace logging unless ``APPINSIGHTS_DISABLE_TRACE_LOGGING`` is
set in the Flask config.
Args:
app (flask.Flask). the Flask application for which to initialize the extension.
"""
enabled = not app.config.get(CONF_DISABLE_TRACE_LOGGING, False)
if not enabled:
return
if self._appinsights_key:
self._trace_log_handler_grantee = LoggingHandler(
self._appinsights_key, telemetry_channel=self._channel)
app.logger.addHandler(self._trace_log_handler_grantee)
def _init_exception_logging(self, app):
"""
Sets up exception logging unless ``APPINSIGHTS_DISABLE_EXCEPTION_LOGGING``
is set in the Flask config.
Args:
app (flask.Flask). the Flask application for which to initialize the extension.
"""
enabled = not app.config.get(CONF_DISABLE_EXCEPTION_LOGGING, False)
if not enabled:
return
if self._appinsights_key:
self._exception_telemetry_client_grantee = TelemetryClient(
self._appinsights_key, telemetry_channel=self._channel)
@app.errorhandler(Exception)
def exception_handler(exception):
try:
raise exception
except Exception:
if self._exception_telemetry_client_grantee:
self._exception_telemetry_client_grantee.track_exception()
if self._exception_telemetry_client_ai4e:
self._exception_telemetry_client_ai4e.track_exception()
finally:
raise exception
def flush(self):
"""Flushes the queued up telemetry to the service."""
print("trying all flush")
if self._requests_middleware:
self._requests_middleware.flush()
if self._trace_log_handler_grantee:
self._trace_log_handler_grantee.flush()
if self._trace_log_handler_ai4e:
print("Trying trace flush...")
self._trace_log_handler_ai4e.flush()
print("Trace flush finsihed.")
if self._exception_telemetry_client_grantee:
self._exception_telemetry_client_grantee.flush()
if self._exception_telemetry_client_ai4e:
self._exception_telemetry_client_ai4e.flush()
tc.flush()
#Sending a metric telemetry item
from applicationinsights import TelemetryClient
tc = TelemetryClient('<YOUR INSTRUMENTATION KEY GOES HERE>')
tc.track_metric('My Metric', 42)
tc.flush()
#Sending an exception telemetry item with custom properties and measurements
import sys
from applicationinsights import TelemetryClient
tc = TelemetryClient('<YOUR INSTRUMENTATION KEY GOES HERE>')
try:
raise Exception('blah')
except:
tc.track_exception()
try:
raise Exception("blah")
except:
tc.track_exception(*sys.exc_info(), properties={ 'foo': 'bar' }, measurements={ 'x': 42 })
tc.flush()
Configuring context for a telemetry client instance
from applicationinsights import TelemetryClient
tc = TelemetryClient('<YOUR INSTRUMENTATION KEY GOES HERE>')
tc.context.application.ver = '1.2.3'
tc.context.device.id = 'My current device'
tc.context.device.oem_name = 'Asus'
tc.context.device.model = 'X31A'
tc.context.device.type = "Other"
class AppinsightsBotTelemetryClient(BotTelemetryClient):
def __init__(self, instrumentation_key: str):
self._instrumentation_key = instrumentation_key
self._context = TelemetryContext()
context.instrumentation_key = self._instrumentation_key
# context.user.id = 'BOTID' # telemetry_channel.context.session.
# context.session.id = 'BOTSESSION'
# set up channel with context
self._channel = TelemetryChannel(context)
# telemetry_channel.context.properties['my_property'] = 'my_value'
self._client = TelemetryClient(self._instrumentation_key,
self._channel)
def track_pageview(self,
name: str,
url: str,
duration: int = 0,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None) -> None:
"""
Send information about the page viewed in the application (a web page for instance).
:param name: the name of the page that was viewed.
:param url: the URL of the page that was viewed.
:param duration: the duration of the page view in milliseconds. (defaults to: 0)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
"""
self._client.track_pageview(name, url, duration, properties,
measurements)
def track_exception(self,
type_exception: type = None,
value: Exception = None,
tb: traceback = None,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None) -> None:
"""
Send information about a single exception that occurred in the application.
:param type_exception: the type of the exception that was thrown.
:param value: the exception that the client wants to send.
:param tb: the traceback information as returned by :func:`sys.exc_info`.
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
"""
self._client.track_exception(type_exception, value, tb, properties,
measurements)
def track_event(self,
name: str,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None) -> None:
"""
Send information about a single event that has occurred in the context of the application.
:param name: the data to associate to this event.
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
"""
self._client.track_event(name, properties, measurements)
def track_metric(self,
name: str,
value: float,
type: TelemetryDataPointType = None,
count: int = None,
min: float = None,
max: float = None,
std_dev: float = None,
properties: Dict[str, object] = None) -> NotImplemented:
"""
Send information about a single metric data point that was captured for the application.
:param name: The name of the metric that was captured.
:param value: The value of the metric that was captured.
:param type: The type of the metric. (defaults to: TelemetryDataPointType.aggregation`)
:param count: the number of metrics that were aggregated into this data point. (defaults to: None)
:param min: the minimum of all metrics collected that were aggregated into this data point. (defaults to: None)
:param max: the maximum of all metrics collected that were aggregated into this data point. (defaults to: None)
:param std_dev: the standard deviation of all metrics collected that were aggregated into this data point. (defaults to: None)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
"""
self._client.track_metric(name, value, type, count, min, max, std_dev,
properties)
def track_trace(self,
name: str,
properties: Dict[str, object] = None,
severity=None):
"""
Sends a single trace statement.
:param name: the trace statement.\n
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\n
:param severity: the severity level of this trace, one of DEBUG, INFO, WARNING, ERROR, CRITICAL
"""
self._client.track_trace(name, properties, severity)
def track_request(self,
name: str,
url: str,
success: bool,
start_time: str = None,
duration: int = None,
response_code: str = None,
http_method: str = None,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None,
request_id: str = None):
"""
Sends a single request that was captured for the application.
:param name: The name for this request. All requests with the same name will be grouped together.
:param url: The actual URL for this request (to show in individual request instances).
:param success: True if the request ended in success, False otherwise.
:param start_time: the start time of the request. The value should look the same as the one returned by :func:`datetime.isoformat()` (defaults to: None)
:param duration: the number of milliseconds that this request lasted. (defaults to: None)
:param response_code: the response code that this request returned. (defaults to: None)
:param http_method: the HTTP method that triggered this request. (defaults to: None)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
:param request_id: the id for this request. If None, a new uuid will be generated. (defaults to: None)
"""
self._client.track_request(name, url, success, start_time, duration,
response_code, http_method, properties,
measurements, request_id)
def track_dependency(self,
name: str,
data: str,
type: str = None,
target: str = None,
duration: int = None,
success: bool = None,
result_code: str = None,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None,
dependency_id: str = None):
"""
Sends a single dependency telemetry that was captured for the application.
:param name: the name of the command initiated with this dependency call. Low cardinality value. Examples are stored procedure name and URL path template.
:param data: the command initiated by this dependency call. Examples are SQL statement and HTTP URL with all query parameters.
:param type: the dependency type name. Low cardinality value for logical grouping of dependencies and interpretation of other fields like commandName and resultCode. Examples are SQL, Azure table, and HTTP. (default to: None)
:param target: the target site of a dependency call. Examples are server name, host address. (default to: None)
:param duration: the number of milliseconds that this dependency call lasted. (defaults to: None)
:param success: true if the dependency call ended in success, false otherwise. (defaults to: None)
:param result_code: the result code of a dependency call. Examples are SQL error code and HTTP status code. (defaults to: None)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
:param id: the id for this dependency call. If None, a new uuid will be generated. (defaults to: None)
"""
self._client.track_dependency(name, data, type, target, duration,
success, result_code, properties,
measurements, dependency_id)
class RaftUtils():
def __init__(self):
work_directory = os.environ['RAFT_WORK_DIRECTORY']
with open(os.path.join(work_directory, 'task-config.json'),
'r') as task_config:
self.config = json.load(task_config)
connection_str = os.environ['RAFT_SB_OUT_SAS']
self.topic_client = TopicClient.from_connection_string(connection_str)
self.telemetry_client = TelemetryClient(
instrumentation_key=os.environ['RAFT_APP_INSIGHTS_KEY'])
self.job_id = os.environ['RAFT_JOB_ID']
self.container_name = os.environ['RAFT_CONTAINER_NAME']
self.telemetry_properties = {
"jobId": self.job_id,
"taskIndex": os.environ['RAFT_TASK_INDEX'],
"containerName": self.container_name
}
def report_status(self, state, details):
m = {
'eventType': 'JobStatus',
'message': {
'tool': 'ZAP',
'jobId': self.job_id,
'agentName': self.container_name,
'details': details,
'utcEventTime': time.strftime('%Y-%m-%d %H:%M:%S',
time.gmtime()),
'state': state
}
}
msg = Message(str.encode(json.dumps(m)))
self.topic_client.send(msg)
def report_status_created(self, details=None):
self.report_status('Created', details)
def report_status_running(self, details=None):
self.report_status('Running', details)
def report_status_error(self, details=None):
self.report_status('Error', details)
def report_status_completed(self, details=None):
self.report_status('Completed', details)
def log_trace(self, trace):
self.telemetry_client.track_trace(trace,
properties=self.telemetry_properties)
def log_exception(self):
self.telemetry_client.track_exception(
properties=self.telemetry_properties)
def flush(self):
self.telemetry_client.flush()
def get_swagger_target(self):
swagger = self.config.get("swaggerLocation")
if swagger and swagger.get("url"):
return swagger["url"]
elif swagger.get("filePath"):
return swagger["filePath"]
print('Loading Keys')
client = SecretClient(vault_url=KVUri, credential=credential)
print(client.get_secret("test").value)
AUTH_TOKEN = client.get_secret("TokenEH").value
DSN_HOST = client.get_secret("DNSHostEH").value
DB_NAME = client.get_secret("DbNameEH").value
DB_USER = client.get_secret("DbUserEH").value
DB_PASSWORD = client.get_secret("DbPasswordEH").value
DB_PORT = client.get_secret("DNSPortEH").value
# print(AUTH_TOKEN)
except:
print('Error Occured in Fetching Keys')
print(*sys.exc_info())
tc.track_exception(*sys.exc_info(),
properties={
"type": "Error Occured in Fetching Keys",
"function": "getKeys"
})
tc.flush()
test_db = dict(host=DSN_HOST,
database=DB_NAME,
user=DB_USER,
password=DB_PASSWORD,
port=DB_PORT)
static_db = PgsqlExecutor(test_db)
db = PGExecutor(username=DB_USER,
password=DB_PASSWORD,
host=DSN_HOST,
port=DB_PORT,
class RaftUtils():
def __init__(self, tool_name):
from applicationinsights import TelemetryClient
from azure.servicebus import ServiceBusClient, ServiceBusMessage
self.config = task_config()
connection_str = os.environ['RAFT_SB_OUT_SAS']
self.sb_client = ServiceBusClient.from_connection_string(
connection_str)
self.topic_client = self.sb_client.get_topic_sender(
self.sb_client._entity_name)
self.telemetry_client = TelemetryClient(
instrumentation_key=os.environ['RAFT_APP_INSIGHTS_KEY'])
self.job_id = os.environ['RAFT_JOB_ID']
self.container_name = os.environ['RAFT_CONTAINER_NAME']
self.tool_name = tool_name
self.telemetry_properties = {
"jobId": self.job_id,
"taskIndex": os.environ['RAFT_TASK_INDEX'],
"containerName": self.container_name
}
self.newSbMessage = ServiceBusMessage
def report_bug(self, bugDetails):
m = {
'eventType': 'BugFound',
'message': {
'tool': self.tool_name,
'jobId': self.job_id,
'agentName': self.container_name,
'bugDetails': bugDetails
}
}
msg = self.newSbMessage(str.encode(json.dumps(m)))
self.topic_client.send_messages([msg])
def report_status(self, state, details):
m = {
'eventType': 'JobStatus',
'message': {
'tool': self.tool_name,
'jobId': self.job_id,
'agentName': self.container_name,
'details': details,
'utcEventTime': time.strftime('%Y-%m-%d %H:%M:%S',
time.gmtime()),
'state': state
}
}
msg = self.newSbMessage(str.encode(json.dumps(m)))
self.topic_client.send_messages([msg])
def report_status_created(self, details=None):
self.report_status('Created', details)
def report_status_running(self, details=None):
self.report_status('Running', details)
def report_status_error(self, details=None):
self.report_status('Error', details)
def report_status_completed(self, details=None):
self.report_status('Completed', details)
def log_trace(self, trace):
self.telemetry_client.track_trace(trace,
properties=self.telemetry_properties)
def log_exception(self):
self.telemetry_client.track_exception(
properties=self.telemetry_properties)
def flush(self):
self.telemetry_client.flush()
self.sb_client.close()
class ApplicationInsightsTelemetryClient(BotTelemetryClient):
def __init__(self, instrumentation_key: str):
self._instrumentation_key = instrumentation_key
self._client = TelemetryClient(self._instrumentation_key)
# Telemetry Processor
def telemetry_processor(data, context):
post_data = IntegrationPostData().activity_json
# Override session and user id
from_prop = post_data['from'] if 'from' in post_data else None
user_id = from_prop['id'] if from_prop != None else None
channel_id = post_data[
'channelId'] if 'channelId' in post_data else None
conversation = post_data[
'conversation'] if 'conversation' in post_data else None
conversation_id = conversation[
'id'] if 'id' in conversation else None
context.user.id = channel_id + user_id
context.session.id = conversation_id
# Additional bot-specific properties
if 'activityId' in post_data:
data.properties["activityId"] = post_data['activityId']
if 'channelId' in post_data:
data.properties["channelId"] = post_data['channelId']
if 'activityType' in post_data:
data.properties["activityType"] = post_data['activityType']
self._client.add_telemetry_processor(telemetry_processor)
def track_pageview(self,
name: str,
url: str,
duration: int = 0,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None) -> None:
"""
Send information about the page viewed in the application (a web page for instance).
:param name: the name of the page that was viewed.
:param url: the URL of the page that was viewed.
:param duration: the duration of the page view in milliseconds. (defaults to: 0)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
"""
self._client.track_pageview(name, url, duration, properties,
measurements)
def track_exception(self,
type_exception: type = None,
value: Exception = None,
tb: traceback = None,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None) -> None:
"""
Send information about a single exception that occurred in the application.
:param type_exception: the type of the exception that was thrown.
:param value: the exception that the client wants to send.
:param tb: the traceback information as returned by :func:`sys.exc_info`.
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
"""
self._client.track_exception(type_exception, value, tb, properties,
measurements)
def track_event(self,
name: str,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None) -> None:
"""
Send information about a single event that has occurred in the context of the application.
:param name: the data to associate to this event.
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
"""
self._client.track_event(name, properties, measurements)
def track_metric(self,
name: str,
value: float,
type: TelemetryDataPointType = None,
count: int = None,
min: float = None,
max: float = None,
std_dev: float = None,
properties: Dict[str, object] = None) -> NotImplemented:
"""
Send information about a single metric data point that was captured for the application.
:param name: The name of the metric that was captured.
:param value: The value of the metric that was captured.
:param type: The type of the metric. (defaults to: TelemetryDataPointType.aggregation`)
:param count: the number of metrics that were aggregated into this data point. (defaults to: None)
:param min: the minimum of all metrics collected that were aggregated into this data point. (defaults to: None)
:param max: the maximum of all metrics collected that were aggregated into this data point. (defaults to: None)
:param std_dev: the standard deviation of all metrics collected that were aggregated into this data point. (defaults to: None)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
"""
self._client.track_metric(name, value, type, count, min, max, std_dev,
properties)
def track_trace(self,
name: str,
properties: Dict[str, object] = None,
severity=None):
"""
Sends a single trace statement.
:param name: the trace statement.\n
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\n
:param severity: the severity level of this trace, one of DEBUG, INFO, WARNING, ERROR, CRITICAL
"""
self._client.track_trace(name, properties, severity)
def track_request(self,
name: str,
url: str,
success: bool,
start_time: str = None,
duration: int = None,
response_code: str = None,
http_method: str = None,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None,
request_id: str = None):
"""
Sends a single request that was captured for the application.
:param name: The name for this request. All requests with the same name will be grouped together.
:param url: The actual URL for this request (to show in individual request instances).
:param success: True if the request ended in success, False otherwise.
:param start_time: the start time of the request. The value should look the same as the one returned by :func:`datetime.isoformat()` (defaults to: None)
:param duration: the number of milliseconds that this request lasted. (defaults to: None)
:param response_code: the response code that this request returned. (defaults to: None)
:param http_method: the HTTP method that triggered this request. (defaults to: None)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
:param request_id: the id for this request. If None, a new uuid will be generated. (defaults to: None)
"""
self._client.track_request(name, url, success, start_time, duration,
response_code, http_method, properties,
measurements, request_id)
def track_dependency(self,
name: str,
data: str,
type: str = None,
target: str = None,
duration: int = None,
success: bool = None,
result_code: str = None,
properties: Dict[str, object] = None,
measurements: Dict[str, object] = None,
dependency_id: str = None):
"""
Sends a single dependency telemetry that was captured for the application.
:param name: the name of the command initiated with this dependency call. Low cardinality value. Examples are stored procedure name and URL path template.
:param data: the command initiated by this dependency call. Examples are SQL statement and HTTP URL with all query parameters.
:param type: the dependency type name. Low cardinality value for logical grouping of dependencies and interpretation of other fields like commandName and resultCode. Examples are SQL, Azure table, and HTTP. (default to: None)
:param target: the target site of a dependency call. Examples are server name, host address. (default to: None)
:param duration: the number of milliseconds that this dependency call lasted. (defaults to: None)
:param success: true if the dependency call ended in success, false otherwise. (defaults to: None)
:param result_code: the result code of a dependency call. Examples are SQL error code and HTTP status code. (defaults to: None)
:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)
:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)
:param id: the id for this dependency call. If None, a new uuid will be generated. (defaults to: None)
"""
self._client.track_dependency(name, data, type, target, duration,
success, result_code, properties,
measurements, dependency_id)
def flush(self):
"""Flushes data in the queue. Data in the queue will be sent either immediately irrespective of what sender is
being used.
"""
self._client.flush()
