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()
