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)
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 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 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
}
)
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 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)
from opencensus.trace.samplers import always_on, always_off
from opencensus.trace.tracer import Tracer
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
def is_enabled():
return getattr(settings, 'TRACING_ENABLED', False)
# Setup the exporter
ze = zipkin.ZipkinExporter(service_name=getattr(settings, 'TRACING_SERVICE',
'snoop'),
host_name=getattr(settings, 'TRACING_HOST',
'zipkin'),
port=getattr(settings, 'TRACING_PORT', 9411),
endpoint=getattr(settings, 'TRACING_API',
'/api/v2/spans'))
# If enabled configure 100% sample rate, otherwise, 0% sample rate
if is_enabled():
sampler = always_on.AlwaysOnSampler()
else:
sampler = always_off.AlwaysOffSampler()
# Set the tracer to use the exporter
# Get the global singleton Tracer object
tracer = Tracer(exporter=ze, sampler=sampler)
tracer.span('root')
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from azure.identity import ClientSecretCredential
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer
tenant_id = "<tenant-id>"
client_id = "<client-id>"
client_secret = "<client-secret>"
credential = ClientSecretCredential(tenant_id=tenant_id,
client_id=client_id,
client_secret=client_secret)
tracer = Tracer(exporter=AzureExporter(
credential=credential, connection_string="<your-connection-string>"),
sampler=ProbabilitySampler(1.0))
with tracer.span(name='foo'):
print('Hello, World!')
input(...)
from dapr.clients import DaprClient
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 AlwaysOnSampler
ze = ZipkinExporter(service_name="python-example",
host_name='localhost',
port=9411,
endpoint='/api/v2/spans')
tracer = Tracer(exporter=ze, sampler=AlwaysOnSampler())
with tracer.span(name="main") as span:
with DaprClient(tracer=tracer) as d:
num_messages = 2
for i in range(num_messages):
# Create a typed message with content type and body
resp = d.invoke_method(
'invoke-receiver',
'say',
data=json.dumps({
'id': i,
'message': 'hello world'
}),
)
# Print the response
class APIService():
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')))
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'))),
sampler=ProbabilitySampler(rate=float(sampling_rate)),
)
self.app.before_request(self.before_request)
def health_check(self):
print("Health check call successful.")
return 'Health check OK'
def api_func(self,
is_async,
api_path,
methods,
request_processing_function,
maximum_concurrent_requests,
content_types=None,
content_max_length=None,
trace_name=None,
*args,
**kwargs):
def decorator_api_func(func):
if not self.api_prefix + api_path in self.func_properties:
self.func_properties[self.api_prefix + api_path] = {
MAX_REQUESTS_KEY_NAME: maximum_concurrent_requests,
CONTENT_TYPE_KEY_NAME: content_types,
CONTENT_MAX_KEY_NAME: content_max_length
}
self.func_request_counts[self.api_prefix + api_path] = 0
@wraps(func)
def api(*args, **kwargs):
internal_args = {"func": func, "api_path": api_path}
if request_processing_function:
return_values = request_processing_function(request)
combined_kwargs = {
**internal_args,
**kwargs,
**return_values
}
else:
combined_kwargs = {**internal_args, **kwargs}
if is_async:
task_info = self.api_task_manager.AddTask(request)
taskId = str(task_info['TaskId'])
combined_kwargs["taskId"] = taskId
self.wrap_async_endpoint(trace_name, *args,
**combined_kwargs)
return 'TaskId: ' + taskId
else:
return self.wrap_sync_endpoint(trace_name, *args,
**combined_kwargs)
api.__name__ = 'api_' + api_path.replace('/', '')
print("Adding url rule: " + self.api_prefix + api_path + ", " +
api.__name__)
self.app.add_url_rule(self.api_prefix + api_path,
view_func=api,
methods=methods,
provide_automatic_options=True)
return decorator_api_func
def api_async_func(self,
api_path,
methods,
request_processing_function=None,
maximum_concurrent_requests=None,
content_types=None,
content_max_length=None,
trace_name=None,
*args,
**kwargs):
is_async = True
return self.api_func(is_async, api_path, methods,
request_processing_function,
maximum_concurrent_requests, content_types,
content_max_length, trace_name, *args, **kwargs)
def api_sync_func(self,
api_path,
methods,
request_processing_function=None,
maximum_concurrent_requests=None,
content_types=None,
content_max_length=None,
trace_name=None,
*args,
**kwargs):
is_async = False
return self.api_func(is_async, api_path, methods,
request_processing_function,
maximum_concurrent_requests, content_types,
content_max_length, trace_name, *args, **kwargs)
def initialize_term(self, signum, frame):
print('Signal handler called with signal: ' + signum)
print(
'SIGINT received, service is terminating and will no longer accept requests.'
)
self.is_terminating = True
def before_request(self):
# Don't accept a request if SIGTERM has been called on this instance.
if (self.is_terminating):
print('Process is being terminated. Request has been denied.')
abort(503, {'message': 'Service is busy, please try again later.'})
if request.path in self.func_properties:
if (self.func_properties[request.path][CONTENT_TYPE_KEY_NAME]
and not request.content_type in self.func_properties[
request.path][CONTENT_TYPE_KEY_NAME]):
print('Invalid content type. Request has been denied.')
abort(
401, {
'message':
'Content-type must be ' + self.func_properties[
request.path][CONTENT_TYPE_KEY_NAME]
})
if (self.func_properties[request.path][CONTENT_MAX_KEY_NAME]
and request.content_length >
self.func_properties[request.path][CONTENT_MAX_KEY_NAME]):
print('Request is too large. Request has been denied.')
abort(
413, {
'message':
'Request content too large (' +
str(request.content_length) +
"). Must be smaller than: " + str(self.func_properties[
request.path][CONTENT_MAX_KEY_NAME])
})
denied_request = 0
if (self.func_request_counts[request.path] + 1 >
self.func_properties[request.path][MAX_REQUESTS_KEY_NAME]):
print('Current requests: ' +
str(self.func_request_counts[request.path] + 1))
print('Max requests: ' + str(self.func_properties[request.path]
[MAX_REQUESTS_KEY_NAME]))
denied_request = 1
print('Service is busy. Request has been denied.')
abort(503,
{'message': 'Service is busy, please try again later.'})
if (disable_request_metric == 'False'):
self.log.track_metric(
APP_INSIGHTS_REQUESTS_KEY_NAME + request.path,
denied_request)
def increment_requests(self, api_path):
self.func_request_counts[self.api_prefix + api_path] += 1
def decrement_requests(self, api_path):
self.func_request_counts[self.api_prefix + api_path] -= 1
def wrap_sync_endpoint(self, trace_name=None, *args, **kwargs):
if (self.tracer):
if (not trace_name):
api_path = kwargs['api_path']
trace_name = api_path
with self.tracer.span(name=trace_name) as span:
return self._execute_func_with_counter(*args, **kwargs)
else:
return self._execute_func_with_counter(*args, **kwargs)
def wrap_async_endpoint(self, trace_name=None, *args, **kwargs):
if (self.tracer):
if (not trace_name):
api_path = kwargs['api_path']
trace_name = api_path
with self.tracer.span(name=trace_name) as span:
self._create_and_execute_thread(*args, **kwargs)
else:
self._create_and_execute_thread(*args, **kwargs)
def _create_and_execute_thread(self, *args, **kwargs):
kwargs['request'] = request
thread = Thread(target=self._execute_func_with_counter,
args=args,
kwargs=kwargs)
thread.start()
def _log_and_fail_exeception(self, **kwargs):
if ('taskId' in kwargs):
taskId = kwargs['taskId']
if taskId:
self.log.log_exception(sys.exc_info()[0], taskId)
self.api_task_manager.FailTask(taskId,
'Task failed - try again')
else:
self.log.log_exception(sys.exc_info()[0])
else:
self.log.log_exception(sys.exc_info()[0])
def _execute_func_with_counter(self, *args, **kwargs):
func = kwargs['func']
api_path = kwargs['api_path']
self.increment_requests(api_path)
try:
r = func(*args, **kwargs)
return r
except HTTPException as e:
self._log_and_fail_exeception(**kwargs)
return e
except:
print(sys.exc_info()[0])
self._log_and_fail_exeception(**kwargs)
abort(500)
finally:
self.decrement_requests(api_path)
# Copyright 2019, OpenCensus Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import requests
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace import config_integration
from opencensus.trace.tracer import Tracer
if __name__ == '__main__':
config_integration.trace_integrations(['requests'])
# TODO: you need to specify the instrumentation key in the
# APPINSIGHTS_INSTRUMENTATIONKEY environment variable.
tracer = Tracer(exporter=AzureExporter())
with tracer.span(name='parent'):
with tracer.span(name='child'):
response = requests.get(url='http://localhost:8080/')
print(response.status_code)
print(response.text)
from opencensus.trace.tracer import Tracer
config_integration.trace_integrations(['logging'])
logger = logging.getLogger(__name__)
handler = AzureLogHandler(connection_string='InstrumentationKey=<Your Key>')
handler.setFormatter(logging.Formatter('%(traceId)s %(spanId)s %(message)s'))
logger.addHandler(handler)
tracer = Tracer(
exporter=AzureExporter(connection_string='InstrumentationKey=<Your Key>'),
sampler=ProbabilitySampler(1.0)
)
logger.warning('Before the span')
with tracer.span(name='azka_test_1'):
logger.warning('In the span azka_test_1')
with tracer.span(name='azka_test_2'):
logger.warning('In the span azka_test_2')
logger.warning('After the span')
input("...asdfd")
##traces
## | where message contains 'azka_test'
logger.addHandler(handler)
exporter = metrics_exporter.new_metrics_exporter(connection_string=cs)
config_integration.trace_integrations(['requests'])
tracer = Tracer(
exporter=AzureExporter(connection_string=cs),
sampler=ProbabilitySampler(1.0),
)
logger.error("Ale błąd")
for i in range(10):
print(psutil.virtual_memory())
time.sleep(5)
with tracer.span(name='parent'):
response = requests.get(url='https://www.wikipedia.org/wiki/Rabbit')
print(response.status_code)
properties = {
'custom_dimensions': {
'key_1': 'value_1',
'key_2': 'value_2'
}
}
try:
result = 1 / 0 # generate a ZeroDivisionError
except Exception as exc:
logger.exception(exc, extra=properties)
logger.warning("Komunikat WARNING")
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
from opencensus.ext.azure.log_exporter import AzureLogHandler
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace import config_integration
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer
config_integration.trace_integrations(['logging'])
logger = logging.getLogger(__name__)
# TODO: you need to specify the instrumentation key in the
# APPINSIGHTS_INSTRUMENTATIONKEY environment variable.
handler = AzureLogHandler()
logger.addHandler(handler)
tracer = Tracer(exporter=AzureExporter(), sampler=ProbabilitySampler(1.0))
logger.warning('Before the span')
with tracer.span(name='test'):
logger.warning('In the span')
logger.warning('After the span')
exporter=EXPORTER,
sampler=SAMPLER,
)
# Add tracing for PostgreSQL
config_integration.trace_integrations(['postgresql'])
# Configure logging from settings.py
logging.config.dictConfig(getattr(django.conf.settings, 'LOGGING', {}))
# Add logging integration
config_integration.trace_integrations(['logging'])
logger = logging.getLogger(__name__)
if getattr(django.conf.settings, 'DEBUG'):
try:
from logging_tree import printout
printout()
except:
pass # optional logging_tree not in venv.
# Run with tracing
# TODO: Currently the manage.py command is showing as a dependency. Can I turn it into the node itself?
# TODO: tracemanage.py node is showing with 0 calls and 0ms
with TRACER.span(name='manage.py/{0}'.format(sys.argv[1])) as span:
span.span_kind = span_module.SpanKind.CLIENT
TRACER.add_attribute_to_current_span("http.method", "CLI")
TRACER.add_attribute_to_current_span(
"http.route", 'manage.py/{0}'.format(sys.argv[1]))
execute_from_command_line(sys.argv)
def create_dependency(name=name, message=message):
tracer = Tracer(exporter=AzureExporter(
connection_string='InstrumentationKey=%s' % (instrument_key)),
sampler=ProbabilitySampler(1.0))
with tracer.span(name=name):
print(message)
