def client(self):
if self._client is None:
# Create a client that submits telemetry parented to the request.
self._client = applicationinsights.TelemetryClient(self.context.instrumentation_key, self._baseclient.channel)
self._client.context.operation.parent_id = self.context.operation.id
return self._client
def create_client(aisettings=None):
global saved_clients, saved_channels
if aisettings is None:
aisettings = load_settings()
if aisettings in saved_clients:
return saved_clients[aisettings]
channel_settings = aisettings.channel_settings
if channel_settings in saved_channels:
channel = saved_channels[channel_settings]
else:
sender = applicationinsights.channel.AsynchronousSender(
service_endpoint_uri=channel_settings.endpoint)
if channel_settings.send_time is not None:
sender.send_time = channel_settings.send_time
if channel_settings.send_interval is not None:
sender.send_interval = channel_settings.send_interval
queue = applicationinsights.channel.AsynchronousQueue(sender)
channel = applicationinsights.channel.TelemetryChannel(None, queue)
saved_channels[channel_settings] = channel
ikey = aisettings.ikey
if ikey is None:
return dummy_client("No ikey specified")
client = applicationinsights.TelemetryClient(aisettings.ikey, channel)
saved_clients[aisettings] = client
return client
def dummy_client(reason):
"""Creates a dummy channel so even if we're not logging telemetry, we can still send
along the real object to things that depend on it to exist"""
sender = applicationinsights.channel.NullSender()
queue = applicationinsights.channel.SynchronousQueue(sender)
channel = applicationinsights.channel.TelemetryChannel(None, queue)
return applicationinsights.TelemetryClient("00000000-0000-0000-0000-000000000000", channel)
def __init__(self):
self.enabled = False
if os.getenv('AML_APP_INSIGHTS_ENABLED'
) == 'true' and 'AML_APP_INSIGHTS_KEY' in os.environ:
instrumentation_key = os.getenv('AML_APP_INSIGHTS_KEY')
exception_channel = self._make_telemetry_channel()
self.telemetry_client = appinsights.TelemetryClient(
instrumentation_key, exception_channel)
self._request_channel = self._make_telemetry_channel()
self._container_id = os.getenv('HOSTNAME', 'Unknown')
self.enabled = True
def __init__(self, instrumentation_key, *args, **kwargs):
"""
Initialize a new instance of the class.
Args:
instrumentation_key (str). the instrumentation key to use while sending telemetry to the service.
"""
if not instrumentation_key:
raise Exception('Instrumentation key was required but not provided')
telemetry_channel = kwargs.get('telemetry_channel')
if 'telemetry_channel' in kwargs:
del kwargs['telemetry_channel']
self.client = applicationinsights.TelemetryClient(instrumentation_key, telemetry_channel)
super(LoggingHandler, self).__init__(*args, **kwargs)
def process_exception(self, request, exception):
if not self._settings.log_exceptions:
return None
if type(exception) is Http404:
return None
_, _, tb = sys.exc_info()
if tb is None or exception is None:
# No actual traceback or exception info, don't bother logging.
return None
client = applicationinsights.TelemetryClient(self._client.context.instrumentation_key, self._client.channel)
if hasattr(request, 'appinsights'):
client.context.operation.parent_id = request.appinsights.request.id
client.track_exception(type(exception), exception, tb)
return None
def __init__(self, instrumentation_key, wsgi_application, *args, **kwargs):
"""
Initialize a new instance of the class.
Args:
instrumentation_key (str). the instrumentation key to use while sending telemetry to the service.\n
wsgi_application (func). the WSGI application that we're wrapping.
"""
if not instrumentation_key:
raise Exception('Instrumentation key was required but not provided')
if not wsgi_application:
raise Exception('WSGI application was required but not provided')
telemetry_channel = kwargs.pop('telemetry_channel', None)
if not telemetry_channel:
sender = applicationinsights.channel.AsynchronousSender()
queue = applicationinsights.channel.AsynchronousQueue(sender)
telemetry_channel = applicationinsights.channel.TelemetryChannel(None, queue)
self.client = applicationinsights.TelemetryClient(instrumentation_key, telemetry_channel)
self.client.context.device.type = "PC"
self._wsgi_application = wsgi_application
self._common_properties = kwargs.pop('common_properties', {})
LOGGER.setLevel(logging.INFO)
FORMATTER = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
#FORMATTER = logging.Formatter("%(asctime)s - %(levelname)s - " +
# "%(pathname)s:%(lineno)s - %(message)s")
STREAM_HANDLER = logging.StreamHandler(stream=sys.stdout)
STREAM_HANDLER.setFormatter(FORMATTER)
LOGGER.addHandler(STREAM_HANDLER)
TELEMETRY_CLIENT = None
INSTRUMENTATION_KEY = os.environ.get("INSTRUMENTATION_KEY")
if INSTRUMENTATION_KEY:
TELEMETRY_CHANNEL = applicationinsights.channel.TelemetryChannel(
None,
applicationinsights.channel.AsynchronousQueue(
applicationinsights.channel.AsynchronousSender()))
TELEMETRY_CLIENT = applicationinsights.TelemetryClient(
INSTRUMENTATION_KEY, TELEMETRY_CHANNEL)
STORAGE_CONNECTION_STRING = os.environ.get("STORAGE_CONNECTION_STRING")
if not STORAGE_CONNECTION_STRING:
raise Exception(
"Please set environment variable STORAGE_CONNECTION_STRING")
STORAGE = dict(
token.split("=", 1) for token in STORAGE_CONNECTION_STRING.split(";"))
# Storage Account Credentials
STORAGE_ACCOUNT_NAME = STORAGE["AccountName"]
STORAGE_KEY = STORAGE["AccountKey"]
LEASE_CONTAINER_NAME = "python-leases"
EVENT_HUB_CONNECTION_STRING = os.environ.get("EVENT_HUB_CONNECTION_STRING")
if not EVENT_HUB_CONNECTION_STRING:
