def process(): filepath = os.path.abspath(sys.argv[0]) app = sys.argv[0].lstrip("./").replace(os.path.sep, '.') if app.endswith('.py'): app = app[:-3] path_name = os.path.abspath(os.path.dirname(__file__)) sys.path.append(path_name) sys.path.append(os.getcwd()) setup_tracer() patch_module(app)
""" Tornado handler example """ import logging import tornado.ioloop import tornado.web from logsense_opentracing.utils import setup_tracer from logsense_opentracing.instrumentation import patch_single, tornado_route # Initialize tracer setup_tracer(component='tornado server') class MainHandler(tornado.web.RequestHandler): # pylint: disable=missing-docstring, abstract-method def get(self): """ Just log and send welcome message """ logging.info('Hello, world') self.write('Hello, world') # Patch handler patch_single('__main__.MainHandler.get', before=tornado_route) if __name__ == "__main__": app = tornado.web.Application([ # pylint: disable=invalid-name
# pylint: disable=missing-docstring import logging import opentracing from logsense_opentracing.tracer import Tracer from logsense_opentracing.utils import setup_tracer # Initialize tracer setup_tracer(component='baggage') with opentracing.tracer.start_active_span('parent-span') as scope: scope.span.set_baggage_item('greeting', 'Aloha!') with opentracing.tracer.start_active_span('child-span', child_of=scope) as new_scope: print(new_scope.span.get_baggage_item('greeting'), ' :)') opentracing.tracer.finish()
def setUp(self): self.sender = MockSender() setup_tracer('test_token', sender=self.sender)
""" Run `nc -lp 8888` in linux console to see which headers was send exactly """ import logging import requests import tornado.ioloop import tornado.web import opentracing from logsense_opentracing.utils import setup_tracer from logsense_opentracing.instrumentation import patch_single, tornado_route, requests_baggage, patch_module # Initialize tracer setup_tracer(component='Requests') patch_single('requests.api.request', before=requests_baggage) with opentracing.tracer.start_active_span('parent-span') as scope: scope.span.set_baggage_item('suitcase', 'My docs with important information') requests.get('http://localhost:8888/', headers={'my-header': 'I\'m using opentracing'})
def setUp(self): self.sender = MockSender() setup_tracer('test_token', sender=self.sender) self.backup_regular_function = resources.regular_function
# pylint: disable=missing-docstring,duplicate-code import logging import random import time import asyncio import opentracing from logsense_opentracing.utils import setup_tracer from logsense_opentracing.tracer import Tracer # Initialize tracer setup_tracer(component='async') ioloop = asyncio.get_event_loop() # pylint: disable=invalid-name async def finish(): # Ensure all logs were sent correctly opentracing.tracer.finish() ioloop.stop() async def app(): # Create parent span with opentracing.tracer.start_active_span('parent-span') as scope: scope.span.set_tag('app_name', 'async') scope.span.set_tag('event', 'true') await asyncio.sleep(random.randint(1, 3)) # Create child span as child of parent-span
def flat_decorator(function): @functools.wraps(function) async def decorated_function(*args, **kwargs): logging.info('Before executing function as flat') result = await function(*args, **kwargs) logging.info('After executing function as flat') return result return decorated_function # Decorator should be patched before using it. patch_async_decorator('__main__.flat_decorator', flat=True) # Use decorators @flat_decorator async def hello_flat_world(): logging.info('Our world is flat') if __name__ == '__main__': # Initialize tracer setup_tracer(component='flat async decorator') # Run application get_event_loop().run_until_complete(hello_flat_world()) # Tracer should be finished explicit, because of multithreading approach wait_on_tracer()
""" Example of instrumentation of asynchronous functions """ import logging from time import sleep import opentracing from logsense_opentracing.utils import setup_tracer from logsense_opentracing.instrumentation import patch_async_single, patch_module from logsense_opentracing.tracer import _DummySender # Initialize dummy tracer setup_tracer(component='patch_module') def finish(): # Ensure all logs were sent correctly opentracing.tracer.finish() class TestModule: @staticmethod def func_1(): # pylint: disable=missing-docstring logging.info('Inside function 1') sleep(3) TestModule.func_2() logging.info('Going out function 1') @staticmethod def func_2(): # pylint: disable=missing-docstring
""" This example shows how to use logging with opentracing and logsense """ import logging import opentracing from logsense_opentracing.tracer import Tracer from logsense_opentracing.handler import OpentracingLogsenseHandler from logsense_opentracing.utils import setup_tracer # Initialize tracer setup_tracer(component='logger') with opentracing.tracer.start_active_span('first') as first: logging.info('Aloha 1') with opentracing.tracer.start_active_span('second', child_of=first) as second: logging.info({ 'content': 'Aloha 2' }) with opentracing.tracer.start_active_span('third', child_of=second): logging.warning('Be aware of good weather!!!') opentracing.tracer.finish()
# imports import logging import opentracing from logsense_opentracing.utils import setup_tracer, wait_on_tracer def hello_logsense(): """ Do nothing, just log """ logging.info('Hello logsense') if __name__ == '__main__': # Initialize tracer setup_tracer(component='simplest logger') # Run application with opentracing.tracer.start_active_span('hello'): hello_logsense() # Tracer should be finished explicitly, because of multithreading approach wait_on_tracer()
def setUp(self): self.sender = MockSender() setup_tracer('test_token', sender=self.sender) self.backup_regular_method = resources.RegularClass.regular_method self.backup_static_method = resources.RegularClass.static_method self.backup_class_method = resources.RegularClass.class_method
""" Extract information from flask request and put into opentracing scope """ import logging from flask import Flask from logsense_opentracing.instrumentation import patch_decorator, flask_route from logsense_opentracing.utils import setup_tracer app = Flask('hello-flask') # Initialize tracer setup_tracer(component='flask') # Decorator should be patched before using it. patch_decorator('flask.Flask.route', before=flask_route, flat=False, only_decorated=True) # Define routing @app.route("/sayHello/<name>") def say_hello(name): """ Log client's name which entered our application and send message to it """ logging.info('User %s entered', name) return 'Hello {}'.format(name)
def decorated_function(*args, **kwargs): logging.info('First parameter is %s', first) result = function(*args, **kwargs) logging.info('Second parameter is %s', second) return result return decorated_function return decorator # Decorator should be patched before using it. patch_decorator('__main__.non_flat_decorator', flat=False) # Use decorators @non_flat_decorator(1, 17) def hello_sphere_world(): logging.info('Our world is sphere') if __name__ == '__main__': # Initialize tracer setup_tracer(component='non flat decorator') # Run application hello_sphere_world() # Tracer should be finished explicit, because of multithreading approach wait_on_tracer()
""" Example of instrumentation of asynchronous functions """ import logging import asyncio import opentracing from logsense_opentracing.utils import setup_tracer from logsense_opentracing.instrumentation import patch_async_single # Initialize tracer setup_tracer(component='async auto') loop = asyncio.get_event_loop() # pylint: disable=invalid-name async def finish(): # Ensure all logs were sent correctly opentracing.tracer.finish() loop.stop() async def func_1(): # pylint: disable=missing-docstring logging.info('Inside function 1') await asyncio.sleep(3) await func_2() logging.info('Going out function 1') async def func_2(): # pylint: disable=missing-docstring
import logging import requests import tornado.ioloop import tornado.web from logsense_opentracing.utils import setup_tracer from logsense_opentracing.instrumentation import patch_single, tornado_route, requests_baggage, patch_module # Initialize tracer setup_tracer(component='Main server') class MainHandler(tornado.web.RequestHandler): def get(self): logging.info('Inside main server') self.write("Hello, world") requests.get('http://localhost:8889/') patch_single('__main__.MainHandler.get', before=tornado_route) patch_single('requests.api.request', before=requests_baggage) patch_module('requests.models.PreparedRequest', recursive=True) def make_app(): return tornado.web.Application([ (r"/", MainHandler) ]) if __name__ == "__main__": app = make_app()