def get_tracer(self, component_name="AppLogger", parent_tracer=None): """Get Tracer Object. Args: component_name (str, optional): Name of logger. Defaults to "AppLogger". parent_tracer([opencensus.trace.tracer], optional): Contains parent tracer required for setting coorelation. Returns: opencensus.trace.tracer: A Tracer. """ self.update_config(self.config) sampler = AlwaysOnSampler() exporter = self.get_log_exporter(component_name) if self.config.get("logging_enabled") != "true": sampler = AlwaysOffSampler() if parent_tracer is None: tracer = Tracer(exporter=exporter, sampler=sampler) else: tracer = Tracer( span_context=parent_tracer.span_context, exporter=exporter, sampler=sampler, ) return tracer
def __init__(self, run): print('Initializing the AppInsightsLogger') self.env = Env() self.run_id = self.get_run_id_and_set_context(run) # Prepare integrations and initialize tracer config_integration.trace_integrations(['httplib', 'logging']) texporter = AzureExporter( connection_string=self.env.app_insights_connection_string) texporter.add_telemetry_processor(self.callback_function) self.tracer = Tracer(exporter=texporter, sampler=ProbabilitySampler( self.env.trace_sampling_rate)) # Create AppInsights Handler and set log format self.logger = logging.getLogger(__name__) self.logger.setLevel( getattr(logging, self.env.log_level.upper(), "WARNING")) handler = AzureLogHandler( connection_string=self.env.app_insights_connection_string, logging_sampling_rate=self.env.log_sampling_rate, ) handler.add_telemetry_processor(self.callback_function) self.logger.addHandler(handler) # initializes metric exporter mexporter = metrics_exporter.new_metrics_exporter( enable_standard_metrics=self.env.enable_standard_metrics, export_interval=self.env.metrics_export_interval, connection_string=self.env.app_insights_connection_string, ) mexporter.add_telemetry_processor(self.callback_function) stats_module.stats.view_manager.register_exporter(mexporter)
def main(): sampler = always_on.AlwaysOnSampler() exporter = print_exporter.PrintExporter() #tracer = Tracer(sampler=sampler, exporter=exporter) je = JaegerExporter(service_name="pitoncito", host_name='jaeger-server', port=9411, endpoint='/api/traces') tracer = Tracer(exporter=je, sampler=always_on.AlwaysOnSampler()) with tracer.span(name='root'): tracer.add_attribute_to_current_span(attribute_key='miclave', attribute_value='mivalor') function_to_trace() with tracer.span(name='child'): function_to_trace() # Get the current tracer tracer = execution_context.get_opencensus_tracer() # Explicitly create spans tracer.start_span() # Get current span execution_context.get_current_span() # Explicitly end span tracer.end_span()
def process(auth_context, form): """ View function for processing charges. Parameters: auth_context (dict): The authentication context of request. See middlewares/auth.py for more information. form (CheckOutForm): A validated checkout form. See middlewares/form_validation.py for more information. Output: Rendered HTML page. """ # Create an OpenCensus tracer to trace each payment process, and export # the data to Stackdriver Tracing. tracer = Tracer(exporter=sde) trace_id = tracer.span_context.trace_id # Prepare the order with tracer.span(name="prepare_order_info"): product_ids = form.product_ids.data stripe_token = form.stripeToken.data shipping = orders.Shipping(address_1=form.address_1.data, address_2=form.address_2.data, city=form.city.data, state=form.state.data, zip_code=form.zip_code.data, email=form.email.data, mobile=form.mobile.data) amount = product_catalog.calculate_total_price(product_ids) order = orders.Order(amount=amount, shipping=shipping, status="order_created", items=product_ids) order_id = orders.add_order(order) # Stream a Payment event with tracer.span(name="send_payment_event"): if stripe_token: # Publish an event to the topic for new payments. # Cloud Function pay_with_stripe subscribes to the topic and # processes the payment using the Stripe API upon arrival of new # events. # Cloud Function streamEvents (or App Engine service stream-event) # subscribes to the topic and saves the event to BigQuery for # data analytics upon arrival of new events. eventing.stream_event( topic_name=PUBSUB_TOPIC_PAYMENT_PROCESS, event_type='order_created', event_context={ 'order_id': order_id, 'token': stripe_token, # Pass the trace ID in the event so that Cloud Function # pay_with_stripe can continue the trace. 'trace_id': trace_id }) return render_template("charge.html", auth_context=auth_context)
def sleep(request: InvokeMethodRequest) -> InvokeMethodResponse: tracer = Tracer(sampler=AlwaysOnSampler()) with tracer.span(name='sleep') as _: time.sleep(2) print(request.metadata, flush=True) print(request.text(), flush=True) return InvokeMethodResponse(b'SLEEP', "text/plain; charset=UTF-8")
def say(request: InvokeMethodRequest) -> InvokeMethodResponse: tracer = Tracer(sampler=AlwaysOnSampler()) with tracer.span(name='say') as span: data = request.text() span.add_annotation('Request length', len=len(data)) print(request.metadata, flush=True) print(request.text(), flush=True) return InvokeMethodResponse(b'SAY', "text/plain; charset=UTF-8")
def __init__(self, flask_app, logger): self.app = flask_app self.log = logger self.api = Api(self.app) self.is_terminating = False self.func_properties = {} self.func_request_counts = {} self.api_prefix = getenv('API_PREFIX') self.tracer = None self.api_task_manager = TaskManager() signal.signal(signal.SIGINT, self.initialize_term) # Add health check endpoint self.app.add_url_rule(self.api_prefix + '/', view_func=self.health_check, methods=['GET']) print("Adding url rule: " + self.api_prefix + '/') # Add task endpoint self.api.add_resource( Task, self.api_prefix + '/task/<id>', resource_class_kwargs={'task_manager': self.api_task_manager}) print("Adding url rule: " + self.api_prefix + '/task/<int:taskId>') if getenv('APPINSIGHTS_INSTRUMENTATIONKEY', None): azure_exporter = AzureExporter( connection_string='InstrumentationKey=' + str(getenv('APPINSIGHTS_INSTRUMENTATIONKEY')), timeout=getenv('APPINSIGHTS_TIMEOUT', 30.0)) sampling_rate = getenv('TRACE_SAMPLING_RATE', None) if not sampling_rate: sampling_rate = 1.0 self.middleware = FlaskMiddleware( self.app, exporter=azure_exporter, sampler=ProbabilitySampler(rate=float(sampling_rate)), ) self.tracer = Tracer( exporter=AzureExporter( connection_string='InstrumentationKey=' + str(getenv('APPINSIGHTS_INSTRUMENTATIONKEY')), timeout=getenv('APPINSIGHTS_TIMEOUT', 30.0)), sampler=ProbabilitySampler(rate=float(sampling_rate)), ) self.app.before_request(self.before_request)
def trace(name, service_name='snoop'): """Context manager to run a trace. Will set the required context execution parents.""" tracer = Tracer(exporter=get_exporter(service_name), sampler=sampler) try: # if there is another trace on the stack, mask it, so this trace's # spans don't interfere with it with set_parent(None): with set_parent(tracer): with span(name): yield finally: tracer.finish()
def pre_invocation_app_level(cls, logger, context, func_args={}, *args, **kwargs): """An implementation of pre invocation hooks on Function App's level. The Python Worker Extension Interface is defined in https://github.com/Azure/azure-functions-python-library/ blob/dev/azure/functions/extension/app_extension_base.py """ if not cls._exporter: logger.warning( 'Please call OpenCensusExtension.configure() after the import ' 'statement to ensure AzureExporter is setup correctly.') return span_context = TraceContextPropagator().from_headers({ "traceparent": context.trace_context.Traceparent, "tracestate": context.trace_context.Tracestate }) tracer = Tracer(span_context=span_context, exporter=cls._exporter, sampler=ProbabilitySampler(1.0)) setattr(context, 'tracer', tracer)
def initialize_logging(logging_level: int, correlation_id: str = None) -> logging.LoggerAdapter: """ Adds the Application Insights handler for the root logger and sets the given logging level. Creates and returns a logger adapter that integrates the correlation ID, if given, to the log messages. :param logging_level: The logging level to set e.g., logging.WARNING. :param correlation_id: Optional. The correlation ID that is passed on to the operation_Id in App Insights. :returns: A newly created logger adapter. """ logger = logging.getLogger() logger.addHandler(logging.StreamHandler()) # For logging into console app_insights_connection_string = os.getenv("APPLICATIONINSIGHTS_CONNECTION_STRING") try: logger.addHandler(AzureLogHandler(connection_string=app_insights_connection_string)) except ValueError as e: logger.error(f"Failed to set Application Insights logger handler: {e}") config_integration.trace_integrations(['logging']) logging.basicConfig(level=logging_level, format='%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s') Tracer(sampler=AlwaysOnSampler()) logger.setLevel(logging_level) extra = None if correlation_id: extra = {'traceId': correlation_id} adapter = logging.LoggerAdapter(logger, extra) adapter.debug(f"Logger adapter initialized with extra: {extra}") return adapter
async def middlewareOpencensus( request: Request, call_next ): # The middleware function recieves: The request, A function call_next that will recieve the request as a parameter tracer = Tracer(exporter=AzureExporter( connection_string=f'InstrumentationKey={APPINSIGHTS_INSTRUMENTATIONKEY}' ), sampler=ProbabilitySampler(1.0)) # https://opencensus.io/tracing/span/kind/#2 # SpanKind details the relationships between spans in addition to the parent/child relationship. # Spand kind: 0 = UNSEPCIFIED, 1 = SERVER, 2 = CLIENT # Detail explaination of Span : https://opencensus.io/tracing/span/ with tracer.span("main") as span: span.span_kind = SpanKind.SERVER response = await call_next( request ) # call next will pass the request to the corresponding path operation, then returns the response genrated by the corresponding path operation tracer.add_attribute_to_current_span( # current span is a SERVER attribute_key=HTTP_STATUS_CODE, # E.g. 202, 201, 404, 405, 505 attribute_value=response.status_code) tracer.add_attribute_to_current_span(attribute_key=HTTP_URL, attribute_value=str(request.url)) return response
def __init__(self, trace_name): sampler = samplers.AlwaysOnSampler() je = JaegerExporter(service_name=trace_name, host_name="localhost", agent_port=6831, endpoint="/api/traces") self.tracer = Tracer(sampler=sampler, exporter=je)
async def dispatch(self, request: Request, call_next): propagator = TraceContextPropagator() span_context = propagator.from_headers(dict(request.headers)) tracer = Tracer(exporter=self.exporter, sampler=self.sampler, span_context=span_context, propagator=propagator) try: # tracer.span_context.trace_options.set_enabled(True) with tracer.span(f"[{request.method}] {request.url}") as span: span.span_kind = SpanKind.SERVER # if "traceparent" not in request.headers: # trace_ctx = span.context_tracer # trace_options = tracer.span_context.trace_options.trace_options_byte # trace_id = trace_ctx.trace_id # trace_parent = f"00-{trace_id}-{span.span_id}-0{trace_options}" # else: # trace_parent = request.headers['traceparent'] span.add_attribute(HTTP_URL, str(request.url)) span.add_attribute(HTTP_HOST, request.url.hostname) span.add_attribute(HTTP_METHOD, request.method) span.add_attribute(HTTP_PATH, request.url.path) span.add_attribute(HTTP_ROUTE, request.url.path) span.add_attribute("x_forwarded_host", request.headers.get("x_forwarded_host")) for key, value in self.extra_attrs.items(): span.add_attribute(key, value) response = await call_next(request) # response.headers['traceparent'] = trace_parent span.add_attribute(HTTP_STATUS_CODE, response.status_code) return response except Exception as err: logger.error(err, exc_info=True) finally: tracer.finish()
def main(): exporter = stackdriver_exporter.StackdriverExporter() tracer = Tracer(exporter=exporter) tracer_interceptor = client_interceptor.OpenCensusClientInterceptor( tracer, host_port=HOST_PORT) channel = grpc.insecure_channel(HOST_PORT) channel = grpc.intercept_channel(channel, tracer_interceptor) stub = hello_world_pb2_grpc.GreeterStub(channel) response = stub.SayHello(hello_world_pb2.HelloRequest(name='you')) print("Message received: " + response.message)
def Echo(self, request, context): metadata = context.invocation_metadata() logging.debug("Echo metadata: " + str(metadata)) metadata_dict = GetTracingMetadata(context) logging.debug("Metadata dict: " + str(metadata_dict)) if 'x-b3-traceid' in metadata_dict: trace_id = metadata_dict['x-b3-traceid'] logging.debug("Trace ID: " + trace_id) span_context = SpanContext(trace_id=trace_id, span_id=metadata_dict['x-b3-spanid']) tracer = Tracer(span_context=span_context, exporter=exporter, sampler=always_on.AlwaysOnSampler()) with tracer.span(name='echo') as span: logging.debug("Processing Echo: " + str(request)) span.add_attribute("message", request.message) time.sleep(0.2) return echo_pb2.EchoResponse(message=request.message)
def pay_with_stripe(data, context): tracer = Tracer(exporter=sde) if 'data' in data: payment_request_json = base64.b64decode(data.get('data')).decode() payment_request = json.loads(payment_request_json) token = payment_request.get('event_context').get('token') order_id = payment_request.get('event_context').get('order_id') trace_id = payment_request.get('event_context').get('trace_id') tracer.span_context.trace_id = trace_id with tracer.span(name="process_payment"): order_data = firestore.collection('orders').document( order_id).get().to_dict() amount = order_data.get('amount') email = order_data.get('shipping').get('email') try: charge = stripe.Charge.create( # For US Dollars, Stripe use Cent as the unit amount=int(amount * 100), currency='usd', description='Example charge', source=token) order_data['status'] = 'payment_processed' event_type = 'payment_processed' except stripe.error.StripeError as err: print(err) order_data['status'] = 'payment_failed' event_type = 'payment_failed' firestore.collection('orders').document(order_id).set(order_data) stream_event(topic_name=PUBSUB_TOPIC_PAYMENT_COMPLETION, event_type=event_type, event_context={ 'order_id': order_id, 'email': email, 'order': order_data }) return ''
def test_get_span_from_thread(): result = [] def get_span_from_thread(output): current_span = OpenCensusSpan.get_current_span() output.append(current_span) tracer = Tracer(sampler=AlwaysOnSampler()) with tracer.span(name="TestSpan") as span: thread = threading.Thread( target=get_span_from_thread, args=(result,) ) thread.start() thread.join() assert span is result[0] execution_context.clear()
def test_invoke_method_with_tracer(self): tracer = Tracer(sampler=samplers.AlwaysOnSampler(), exporter=print_exporter.PrintExporter()) self.client = DaprClient(headers_callback=lambda: tracer.propagator. to_headers(tracer.span_context)) self.server.set_response(b"FOO") with tracer.span(name="test"): req = common_v1.StateItem(key='test') resp = self.client.invoke_method( self.app_id, self.method_name, http_verb='PUT', data=req, ) request_headers = self.server.get_request_headers() self.assertIn('Traceparent', request_headers) self.assertEqual(b'FOO', resp.data)
async def dispatch(self, request: Request, call_next): if (request.app.extra.get('extra', {}).get('open-census-settings', {})): settings = request.app.extra['extra']['open-census-settings'] self.load_config(settings=settings) if hasattr(request.app, 'trace_exporter'): self.exporter = request.app.trace_exporter span_context = self.propagator.from_headers(request.headers) tracer = Tracer(span_context=span_context, sampler=self.sampler, propagator=self.propagator, exporter=self.exporter) with tracer.span("main") as span: span.span_kind = SpanKind.SERVER self._before_request(request, tracer) response = await call_next(request) self._after_request(response, tracer) return response
def create_trace_dependency(name=name, message=message, message_before=message_before, message_after=message_after): config_integration.trace_integrations(['logging']) logger = logging.getLogger(__name__) handler = AzureLogHandler(connection_string='InstrumentationKey=%s' % (instrument_key)) handler.setFormatter( logging.Formatter('%(traceId)s %(spanId)s %(message)s')) logger.addHandler(handler) tracer = Tracer(exporter=AzureExporter( connection_string='InstrumentationKey=%s' % (instrument_key)), sampler=ProbabilitySampler(1.0)) logger.warning(message_before) with tracer.span(name=name): logger.warning(message) logger.warning(message_after)
def main(): sampler = always_on.AlwaysOnSampler() exporter = print_exporter.PrintExporter() tracer = Tracer(sampler=sampler, exporter=exporter) with tracer.span(name='root'): tracer.add_attribute_to_current_span(attribute_key='example key', attribute_value='example value') function_to_trace() with tracer.span(name='child'): function_to_trace() # Get the current tracer tracer = execution_context.get_opencensus_tracer() # Explicitly create spans tracer.start_span() # Get current span execution_context.get_current_span() # Explicitly end span tracer.end_span()
def create_order(product_ids, stripe_token, shipping): # Create an OpenCensus tracer to trace each payment process, and export # the data to Stackdriver Tracing. tracer = Tracer(exporter=sde) trace_id = tracer.span_context.trace_id # Prepare the order with tracer.span(name="prepare_order_info"): amount = product_catalog.calculate_total_price(product_ids) order = orders.Order(amount=amount, shipping=shipping, status="order_created", items=product_ids) order_id = orders.add_order(order) # Stream a Payment event with tracer.span(name="send_payment_event"): if stripe_token: # Publish an event to the topic for new payments. # Cloud Function pay_with_stripe subscribes to the topic and # processes the payment using the Stripe API upon arrival of new # events. # Cloud Function streamEvents (or App Engine service stream-event) # subscribes to the topic and saves the event to BigQuery for # data analytics upon arrival of new events. eventing.stream_event( topic_name=PUBSUB_TOPIC_PAYMENT_PROCESS, event_type='order_created', event_context={ 'order_id': order_id, 'token': stripe_token, # Pass the trace ID in the event so that Cloud Function # pay_with_stripe can continue the trace. 'trace_id': trace_id, 'email': shipping.email } )
def initialize_logging(logging_level: int, correlation_id: str, add_console_handler: bool = False) -> logging.LoggerAdapter: """ Adds the Application Insights handler for the root logger and sets the given logging level. Creates and returns a logger adapter that integrates the correlation ID, if given, to the log messages. Note: This should be called only once, otherwise duplicate log entries could be produced. :param logging_level: The logging level to set e.g., logging.WARNING. :param correlation_id: Optional. The correlation ID that is passed on to the operation_Id in App Insights. :returns: A newly created logger adapter. """ logger = logging.getLogger() # When using sessions and NEXT_AVAILABLE_SESSION we see regular exceptions which are actually expected # See https://github.com/Azure/azure-sdk-for-python/issues/9402 # Other log entries such as 'link detach' also confuse the logs, and are expected. # We don't want these making the logs any noisier so we raise the logging level for that logger here # To inspect all the loggers, use -> loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] for logger_name in LOGGERS_FOR_ERRORS_ONLY: logging.getLogger(logger_name).setLevel(logging.ERROR) if add_console_handler: console_formatter = logging.Formatter(fmt='%(module)-7s %(name)-7s %(process)-7s %(asctime)s %(levelname)-7s %(message)s') console_handler = logging.StreamHandler() console_handler.setFormatter(console_formatter) logger.addHandler(console_handler) try: azurelog_formatter = AzureLogFormatter() # picks up APPLICATIONINSIGHTS_CONNECTION_STRING automatically azurelog_handler = AzureLogHandler() azurelog_handler.setFormatter(azurelog_formatter) logger.addHandler(azurelog_handler) except ValueError as e: logger.error(f"Failed to set Application Insights logger handler: {e}") config_integration.trace_integrations(['logging']) logging.basicConfig(level=logging_level, format='%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s') Tracer(sampler=AlwaysOnSampler()) logger.setLevel(logging_level) extra = None if correlation_id: extra = {'traceId': correlation_id} adapter = logging.LoggerAdapter(logger, extra) adapter.debug(f"Logger adapter initialized with extra: {extra}") return adapter
def __init__( self, study_id: str, study_file_id: str, matrix_file: str = None, matrix_file_type: str = None, cell_metadata_file: str = None, cluster_file: str = None, subsample=False, ingest_cell_metadata=False, ingest_cluster=False, **kwargs, ): """Initializes variables in Ingest Pipeline""" self.study_id = study_id self.study_file_id = study_file_id self.matrix_file = matrix_file self.matrix_file_type = matrix_file_type if os.environ.get("DATABASE_HOST") is not None: # Needed to run tests in CircleCI. # TODO (SCP-2000): Integrate MongoDB emulator to test_ingest.py, then remove this self.db = self.get_mongo_db() else: self.db = None self.cluster_file = cluster_file self.kwargs = kwargs self.cell_metadata_file = cell_metadata_file if "GOOGLE_CLOUD_PROJECT" in os.environ: # instantiate trace exporter exporter = StackdriverExporter( project_id=os.environ["GOOGLE_CLOUD_PROJECT"]) self.tracer = Tracer(exporter=exporter, sampler=AlwaysOnSampler()) else: self.tracer = nullcontext() if ingest_cell_metadata: self.cell_metadata = self.initialize_file_connection( "cell_metadata", cell_metadata_file) if ingest_cluster: self.cluster = self.initialize_file_connection( "cluster", cluster_file) if subsample: self.cluster_file = cluster_file self.cell_metadata_file = cell_metadata_file
def pre_invocation_app_level(cls, logger: Logger, context: Context, func_args: Dict[str, object] = {}, *args, **kwargs) -> None: if not cls._has_configure_called: raise FunctionExtensionException( 'Please ensure OpenCensusExtension.configure() is called ' 'after the import OpenCensusExtension statement.') span_context = TraceContextPropagator().from_headers({ "traceparent": context.trace_context.Traceparent, "tracestate": context.trace_context.Tracestate }) tracer = Tracer(span_context=span_context, exporter=cls._exporter, sampler=ProbabilitySampler(1.0)) cls._tracers[context.function_name] = tracer setattr(context, 'tracer', tracer)
'InstrumentationKey=bdba70b7-8e6e-4adb-adb5-8fd02df32aea;IngestionEndpoint=https://westus2-1.in.applicationinsights.azure.com/' )) logger.setLevel(logging.INFO) # Metrics exporter = metrics_exporter.new_metrics_exporter( enable_standard_metrics=True, connection_string= 'InstrumentationKey=bdba70b7-8e6e-4adb-adb5-8fd02df32aea;IngestionEndpoint=https://westus2-1.in.applicationinsights.azure.com/' ) # Tracing tracer = Tracer( exporter=AzureExporter( connection_string= 'InstrumentationKey=bdba70b7-8e6e-4adb-adb5-8fd02df32aea;IngestionEndpoint=https://westus2-1.in.applicationinsights.azure.com/' ), sampler=ProbabilitySampler(1.0), ) app = Flask(__name__) # Requests middleware = FlaskMiddleware( app, exporter=AzureExporter( connection_string= "InstrumentationKey=bdba70b7-8e6e-4adb-adb5-8fd02df32aea;IngestionEndpoint=https://westus2-1.in.applicationinsights.azure.com/" ), sampler=ProbabilitySampler(rate=1.0), )
import sys from opencensus.trace.tracer import Tracer from opencensus.trace import time_event as time_event_module from opencensus.ext.zipkin.trace_exporter import ZipkinExporter from opencensus.trace.samplers import always_on # 1a. Setup the exporter ze = ZipkinExporter(service_name="python-quickstart", host_name='localhost', port=9411, endpoint='/api/v2/spans') # 1b. Set the tracer to use the exporter # 2. Configure 100% sample rate, otherwise, few traces will be sampled. # 3. Get the global singleton Tracer object tracer = Tracer(exporter=ze, sampler=always_on.AlwaysOnSampler()) def main(): # 4. Create a scoped span. The span will close at the end of the block. with tracer.span(name="main") as span: for i in range(0, 10): doWork() def doWork(): # 5. Start another span. Because this is within the scope of the "main" span, # this will automatically be a child span. with tracer.span(name="doWork") as span: print("doing busy work") try: time.sleep(0.1) except:
except KeyError: logger.info("Profiler disabled.") tracer = None try: if "DISABLE_TRACING" in os.environ: raise KeyError() else: logger.info("Tracing enabled.") sampler = always_on.AlwaysOnSampler() exporter = stackdriver_exporter.StackdriverExporter( project_id=os.environ.get('GCP_PROJECT_ID'), transport=AsyncTransport) tracer_interceptor = server_interceptor.OpenCensusServerInterceptor( sampler, exporter) tracer = Tracer(exporter=exporter) except (KeyError, DefaultCredentialsError): logger.info("Tracing disabled.") tracer_interceptor = server_interceptor.OpenCensusServerInterceptor() try: if "DISABLE_DEBUGGER" in os.environ: raise KeyError() else: logger.info("Debugger enabled.") try: googleclouddebugger.enable(module='recommendationserver', version='1.0.0') except Exception, err: logger.error("Could not enable debugger")
connection_string= 'InstrumentationKey=15d02af3-bb8b-48ab-937e-7f84588dfce0;IngestionEndpoint=https://westus-0.in.applicationinsights.azure.com/' )) # Metrics exporter = metrics_exporter.new_metrics_exporter( enable_standard_metrics=True, connection_string= 'InstrumentationKey=15d02af3-bb8b-48ab-937e-7f84588dfce0;IngestionEndpoint=https://westus-0.in.applicationinsights.azure.com/' ) # Tracing tracer = Tracer( exporter=AzureExporter( connection_string= 'InstrumentationKey=15d02af3-bb8b-48ab-937e-7f84588dfce0;IngestionEndpoint=https://westus-0.in.applicationinsights.azure.com/' ), sampler=ProbabilitySampler(1.0), ) app = Flask(__name__) # Requests middleware = FlaskMiddleware( app, exporter=AzureExporter( connection_string= "InstrumentationKey=15d02af3-bb8b-48ab-937e-7f84588dfce0;IngestionEndpoint=https://westus-0.in.applicationinsights.azure.com/" ), sampler=ProbabilitySampler(rate=1.0), )
logger.addHandler( AzureEventHandler( connection_string= 'InstrumentationKey=3d3e7bec-d2e0-41b6-b690-7c9cb2020fc2')) # Metrics exporter = metrics_exporter.new_metrics_exporter( enable_standard_metrics=True, connection_string='InstrumentationKey=3d3e7bec-d2e0-41b6-b690-7c9cb2020fc2' ) # Tracing tracer = Tracer( exporter=AzureExporter( connection_string= 'InstrumentationKey=3d3e7bec-d2e0-41b6-b690-7c9cb2020fc2'), sampler=ProbabilitySampler(1.0), ) app = Flask(__name__) # Requests middleware = FlaskMiddleware( app, exporter=AzureExporter( connection_string= "InstrumentationKey=3d3e7bec-d2e0-41b6-b690-7c9cb2020fc2"), sampler=ProbabilitySampler(rate=1.0), ) # Load configurations from environment or config file