Python OpenTracing (obsoleto)

Para instalar manualmente o pacote Instana Python em um virtualenv, pipenv ou contêiner, execute o seguinte comando:

pip install instana==2.5.4

Como alternativa, você pode instalar o pacote Instana Python diretamente do repositório GitHub executando o seguinte comando:

pip install git+https://github.com/instana/python-sensor@v2.5.4

Para instalar manualmente o pacote Instana Python em um virtualenv, pipenv ou contêiner, execute o seguinte comando:

pip install git+https://github.com/instana/python-sensor@v2.4.0

Algumas operações que você deseja rastrear podem ser assíncronas, o que significa que elas retornam imediatamente, mas continuam a funcionar separadamente da sequência principal de instruções. Para rastrear essas operações, por exemplo, com a biblioteca asyncio, você pode usar os métodos de rastreamento relacionados a ' async_tracer da seguinte forma:

import asyncio
from instana.singletons import tracer, async_tracer


async def do_work(parent_span):
    with async_tracer.start_active_span('launch_async_work', child_of=parent_span):
        print('Work stared')
        await asyncio.sleep(1)
        print('Work finished!')

with tracer.start_active_span('launch_uvloop') as sync_scope:
    asyncio.run(do_work(sync_scope.span))

Se quiser rastrear os intervalos em um processo bifurcado, adicione um período de tempo após ' span.finish(). Por exemplo:

 def forked_process(num):
    print(f'in forked process {num}')
    try:
        span = tracer.start_span(f"forked process {num}")
        print(f'sleep 10 for forked process {num}')
        time.sleep(10)
    except Exception as e:
        span.log_exception(e)
    finally:
        span.finish()

    logger.warning(f'sleep 2 for forked process {num}')
    time.sleep(2)   ##  < -- with a sleep after span.finish(), the span can be collected

O rastreamento é local para um thread. Se você criar um novo tópico, o contexto deverá ser transportado para esse novo tópico e, em seguida, retomado. Você pode instrumentar o código para transportar o contexto para novos threads da seguinte forma:

from threading import Thread

def child_thread_function(parent_span):
    with tracer.start_active_span('child_thread_span', child_of=parent_span) as child_scope:
        print('Thread offloaded work goes here')

with tracer.start_active_span('parent_thread_span') as parent_scope:
    thread = Thread(target = child_thread_function, args = (parent_scope.span, ))
    thread.start()
    thread.join()

Você pode instrumentar os trabalhos que estão na fila para serem executados mais tarde da seguinte forma:

# Python 3.8
import asyncio
import datetime
import uvloop
import aiohttp

from instana.singletons import tracer, async_tracer

uvloop.install()

async def launch_async_calls(parent_span):
    with async_tracer.start_active_span('launch_async_calls', child_of=parent_span):
        async with aiohttp.ClientSession() as session:
            async with session.get('https://wikipedia.org') as resp:
               print(resp.status)
               print(await resp.text())

async def run_at(dt, coro):
    await asyncio.sleep((dt - datetime.datetime.now()).total_seconds())
    return await coro

with tracer.start_active_span('launch_uvloop') as sync_scope:
    sync_scope.span.set_tag('span.kind', 'entry')
    asyncio.run(
      run_at(datetime.datetime.now() + datetime.timedelta(seconds=5),
             launch_async_calls(sync_scope.span)))

Para adicionar tags personalizadas a um elemento ` Instana `, implemente o código a seguir utilizando o set_tag método:

with tracer.start_active_span('well_chosen_span_name_here') as scope:
    scope.span.set_tag('custom_tag', 'custom_value')