def lightstep_tracer(job_ix, access_token):
"""Set up a LightStep tracer."""
return lightstep.Tracer(component_name=COMPONENT_NAME + '_' + job_ix,
access_token=access_token,
collector_host=COLLECTOR_HOST,
collector_port=COLLECTOR_PORT,
collector_encryption=COLLECTOR_ENCRYPTION)
def init_opentracing_tracer(tracer, **kwargs):
if tracer == OPENTRACING_BASIC:
from basictracer import BasicTracer # noqa
recorder = kwargs.get('recorder')
sampler = kwargs.get('sampler')
opentracing.tracer = BasicTracer(recorder=recorder, sampler=sampler)
elif tracer == OPENTRACING_INSTANA:
import instana.options as InstanaOpts
import instana.tracer # noqa
service = kwargs.pop('service',
os.environ.get('OPENTRACING_INSTANA_SERVICE'))
log_level = kwargs.pop('log_level', logging.INFO)
instana.tracer.init(
InstanaOpts.Options(service=service, log_level=log_level,
**kwargs))
elif tracer == OPENTRACING_LIGHTSTEP:
import lightstep
# Get Lightstep specific config vars
component_name = kwargs.pop(
'component_name',
os.environ.get('OPENTRACING_LIGHTSTEP_COMPONENT_NAME'))
access_token = kwargs.pop(
'access_token',
os.environ.get('OPENTRACING_LIGHTSTEP_ACCESS_TOKEN'))
collector_host = kwargs.pop(
'collector_host',
os.environ.get('OPENTRACING_LIGHTSTEP_COLLECTOR_HOST',
'collector.lightstep.com'))
collector_port = kwargs.pop(
'collector_port',
int(os.environ.get('OPENTRACING_LIGHTSTEP_COLLECTOR_PORT', 443)))
verbosity = kwargs.pop(
'verbosity',
int(os.environ.get('OPENTRACING_LIGHTSTEP_VERBOSITY', 0)))
if not access_token:
logger.warn('Initializing LighStep tracer with no access_token!')
opentracing.tracer = lightstep.Tracer(component_name=component_name,
access_token=access_token,
collector_host=collector_host,
collector_port=collector_port,
verbosity=verbosity,
**kwargs)
elif tracer == OPENTRACING_JAEGER:
from jaeger_client import Config
service_name = kwargs.pop(
'service_name', os.environ.get('OPENTRACING_JAEGER_SERVICE_NAME'))
config = kwargs.pop('config', {})
jaeger_config = Config(config=config, service_name=service_name)
opentracing.tracer = jaeger_config.initialize_tracer()
else:
opentracing.tracer = opentracing.Tracer()
def serve():
parser = argparse.ArgumentParser()
parser.add_argument('--access_token', help='LightStep Access Token')
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
args = parser.parse_args()
if not args.access_token:
print('You must specify access_token')
sys.exit(-1)
tracer = lightstep.Tracer(
component_name='python.store-server', access_token=args.access_token)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
tracer_interceptor = open_tracing_server_interceptor(
tracer, log_payloads=args.log_payloads)
server = intercept_server(server, tracer_interceptor)
store_pb2.add_StoreServicer_to_server(Store(), server)
server.add_insecure_port('[::]:50051')
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
tracer.flush()
def build_tracer(command, tracer_name, port):
if command['Trace'] and tracer_name == "vanilla":
logging.info("We're using the python tracer.")
import lightstep
return lightstep.Tracer(
component_name='isaac_service',
collector_port=port,
collector_host='localhost',
collector_encryption='none',
use_http=True,
access_token='developer',
# these are much more aggressive than the defaults
# but are common in production
periodic_flush_seconds=REPORTING_PERIOD / 1000,
max_span_records=MAX_BUFFERED_SPANS,
)
elif command['Trace'] and tracer_name == "cpp":
logging.info("We're using the python-cpp tracer.")
import lightstep_native
return lightstep_native.Tracer(
component_name='isaac_service',
access_token='developer',
use_stream_recorder=True,
collector_plaintext=True,
satellite_endpoints=[{
'host': 'localhost',
'port': p
} for p in range(port, port + NUM_SATELLITES)],
max_buffered_spans=MAX_BUFFERED_SPANS,
reporting_period=REPORTING_PERIOD,
)
logging.info("We're using a NoOp tracer.")
return opentracing.Tracer()
def build_tracer():
tracer_name = args.tracer
if args.trace and tracer_name == "vanilla":
logging.info("We're using the python tracer.")
import lightstep
return lightstep.Tracer(
component_name='isaac_service',
collector_port=SATELLITE_PORTS[0],
collector_host='localhost',
collector_encryption='none',
use_http=True,
access_token='developer',
periodic_flush_seconds=REPORTING_PERIOD,
max_span_records=MAX_BUFFERED_SPANS,
)
elif args.trace and tracer_name == "cpp":
logging.info("We're using the python-cpp tracer.")
import lightstep_streaming
return lightstep_streaming.Tracer(
component_name='isaac_service',
access_token='developer',
use_stream_recorder=True,
collector_plaintext=True,
satellite_endpoints=[{
'host': 'localhost',
'port': p
} for p in SATELLITE_PORTS],
max_buffered_spans=MAX_BUFFERED_SPANS,
reporting_period=REPORTING_PERIOD * 10**6, # s --> us
)
logging.info("We're using a NoOp tracer.")
return opentracing.Tracer()
def lightstep_tracer_from_args():
"""Initializes lightstep from the commandline args.
"""
parser = argparse.ArgumentParser()
parser.add_argument('--token',
help='Your LightStep access token.',
default='{your_access_token}')
parser.add_argument(
'--host',
help='The LightStep reporting service host to contact.',
default='collector.lightstep.com')
parser.add_argument('--port',
help='The LightStep reporting service port.',
type=int,
default=443)
parser.add_argument('--use_tls',
help='Whether to use TLS for reporting',
type=bool,
default=True)
parser.add_argument('--component_name',
help='The LightStep component name',
default='NonTrivialExample')
args = parser.parse_args()
return lightstep.Tracer(
component_name=args.component_name,
access_token=args.token,
collector_host=args.host,
collector_port=args.port,
collector_encryption=('tls' if args.use_tls else 'none'))
def lightstep_tracer_from_args():
parser = argparse.ArgumentParser()
parser.add_argument('--token',
help='Your LightStep access token.',
default='')
parser.add_argument(
'--host',
help='The LightStep reporting service host to contact.',
default='collector.lightstep.com')
parser.add_argument('--port',
help='The LightStep reporting service port.',
type=int,
default=443)
parser.add_argument('--use_tls',
help='Whether to use TLS for reporting',
type=bool,
default=True)
parser.add_argument('--component_name',
help='The LightStep component name',
default='bubblesort')
args = parser.parse_args()
return lightstep.Tracer(
component_name=args.component_name,
access_token=args.token,
collector_host=args.host,
collector_port=args.port,
verbosity=1,
collector_encryption=('tls' if args.use_tls else 'none'))
def lightstep_tracer_from_args():
"""Initializes lightstep from the commandline args.
"""
parser = argparse.ArgumentParser()
parser.add_argument('--token',
help='Your LightStep access token.',
default='{your_access_token}')
parser.add_argument(
'--host',
help='The LightStep reporting service host to contact.',
default='collector.lightstep.com')
parser.add_argument('--port',
help='The LightStep reporting service port.',
type=int,
default=443)
parser.add_argument('--no_tls',
help='Disable TLS for reporting',
dest="no_tls",
action='store_true')
parser.add_argument('--component_name',
help='The LightStep component name',
default='TrivialExample')
args = parser.parse_args()
collector_encryption = 'tls'
return lightstep.Tracer(
component_name=args.component_name,
access_token=os.environ['LIGHTSTEP_TOKEN'],
collector_host=args.host,
collector_port=args.port,
collector_encryption=collector_encryption,
)
def __init__(self, tracer=None):
self.tracer = lightstep.Tracer(
component_name=os.environ['COMPONENT_NAME'],
access_token=os.environ['LIGHTSTEP_ACCESS_TOKEN'])
self.downcase_keys = False
self.timestamp_keys = ['endTime', '_time']
self.operation_keys = ['activity', 'path']
self.duration_keys = [
"latencyMillis", "elapsedMillis", "duration", 'dur'
]
self.downcase_keys = True
def test_spans_received(self):
with SatelliteGroup('typical') as satellites:
assert satellites.get_spans_received() == 0
# send 1 span
tracer = lightstep.Tracer(component_name='isaac_service',
collector_port=8360,
collector_host='localhost',
collector_encryption='none',
use_http=True,
access_token='test')
with tracer.start_active_span('TestSpan'):
pass
tracer.flush()
assert satellites.get_spans_received() == 1
def main():
import argparse
parser = argparse.ArgumentParser(description="")
parser.add_argument("--mode",
default="stdio",
help="communication (stdio|tcp)")
parser.add_argument("--addr",
default=4389,
help="server listen (tcp)",
type=int)
parser.add_argument("--debug", action="store_true")
parser.add_argument("--lightstep_token",
default=os.environ.get("LIGHTSTEP_ACCESS_TOKEN"))
parser.add_argument("--python_path")
args = parser.parse_args()
logging.basicConfig(level=(logging.DEBUG if args.debug else logging.INFO))
if args.python_path:
GlobalConfig.PYTHON_PATH = args.python_path
log.info("Setting Python path to %s", GlobalConfig.PYTHON_PATH)
# if args.lightstep_token isn't set, we'll fall back on the default no-op
# opentracing implementation
if args.lightstep_token:
opentracing.tracer = lightstep.Tracer(
component_name="python-langserver",
access_token=args.lightstep_token)
if args.mode == "stdio":
logging.info("Reading on stdin, writing on stdout")
s = LangServer(conn=ReadWriter(sys.stdin, sys.stdout))
s.run()
elif args.mode == "tcp":
host, addr = "0.0.0.0", args.addr
logging.info("Accepting TCP connections on %s:%s", host, addr)
ForkingTCPServer.allow_reuse_address = True
ForkingTCPServer.daemon_threads = True
s = ForkingTCPServer((host, addr), LangserverTCPTransport)
try:
s.serve_forever()
finally:
s.shutdown()
def run():
parser = argparse.ArgumentParser()
parser.add_argument('--access_token', help='LightStep Access Token')
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
args = parser.parse_args()
if not args.access_token:
print('You must specify access_token')
sys.exit(-1)
tracer = lightstep.Tracer(component_name='python.store-client',
access_token=args.access_token)
tracer_interceptor = open_tracing_client_interceptor(
tracer, log_payloads=args.log_payloads)
channel = grpc.insecure_channel('localhost:50051')
channel = intercept_channel(channel, tracer_interceptor)
stub = store_pb2.StoreStub(channel)
read_and_execute(CommandExecuter(stub))
tracer.flush()
import os
from sqlalchemy import MetaData, Table, Integer, String, Column, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import lightstep
import sqlalchemy_opentracing
DB_LOCATION = '/tmp/simple.db'
tracer = lightstep.Tracer(component_name='sqlalchemy-orm-bulk',
access_token='{your_lightstep_token}')
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
if __name__ == '__main__':
if os.path.exists(DB_LOCATION):
os.remove(DB_LOCATION) # cleanup
engine = create_engine('sqlite:///%s' % DB_LOCATION)
session = sessionmaker(bind=engine)()
sqlalchemy_opentracing.init_tracing(tracer)
import urllib2
from pyramid.view import view_config
from pyramid.config import Configurator
import lightstep
import opentracing
import pyramid_opentracing
from waitress import serve
tracer = pyramid_opentracing.PyramidTracer(
lightstep.Tracer(
component_name='pyramid_app',
access_token='{your_lightstep_token}',
))
# Client
@view_config(route_name='client_simple', renderer='json')
@tracer.trace()
def client_simple(request):
url = 'http://127.0.0.1:8080/server/simple'
new_request = urllib2.Request(url)
current_span = tracer.get_span(request)
inject_as_headers(tracer, current_span, new_request)
try:
response = urllib2.urlopen(new_request)
return {'message': 'Made a simple request'}
except urllib2.URLError as e:
return {'error': e}
span.set_tag(opentracing.ext.tags.PEER_HOST_IPV4, host)
carrier_dict = {}
print("Injecting context\n trace id: ", span.context.trace_id)
print(" span id: ", span.context.span_id)
span.tracer.inject(span.context, opentracing.Format.HTTP_HEADERS,
carrier_dict)
for k, v in carrier_dict.items():
print(k, v)
request.add_header(k, v)
return span
if __name__ == "__main__":
opentracing.tracer = lightstep.Tracer(
component_name='hello-python-client',
access_token=os.environ['LIGHTSTEP_TOKEN'])
with opentracing.tracer.start_active_span('TestSpan') as scope:
scope.span.log_event('test message', payload={'life': 42})
url = 'http://localhost:8736/predictions'
request = urllib.request.Request(url)
client_span = before_sending_request(request)
with opentracing.tracer.scope_manager.activate(client_span, True):
response = urllib.request.urlopen(request)
print(response.status)
print(response.read().decode('utf8'))
opentracing.tracer.flush()
from datetime import datetime
from elasticsearch import Elasticsearch
import lightstep
import elasticsearch_opentracing
tracer = lightstep.Tracer(component_name='elasticsearch-explicit',
access_token='{your_lightstep_token}')
if __name__ == '__main__':
elasticsearch_opentracing.init_tracing(tracer, trace_all_requests=False)
es = Elasticsearch(
'127.0.0.1',
transport_class=elasticsearch_opentracing.TracingTransport)
# We want to trace only the creation of the document, not the
# index creation not checking the document was actually created.
with tracer.start_span('main span') as main_span:
elasticsearch_opentracing.set_active_span(main_span)
es.indices.create('test-index', ignore=400)
doc = {
'author': 'john',
'text': 'Find me if you can',
'timestamp': datetime.now(),
}
elasticsearch_opentracing.enable_tracing()
def setUp(self):
self._tracer = lightstep.Tracer(
periodic_flush_seconds=0,
collector_host='localhost')
import os
from sqlalchemy import MetaData, Table, Integer, String, Column, create_engine
from sqlalchemy import select
from sqlalchemy.schema import CreateTable
import lightstep
import sqlalchemy_opentracing
DB_LOCATION = '/tmp/simple.db'
tracer = lightstep.Tracer(component_name='sqlalchemy-childspans',
access_token='{your_lightstep_token}')
if __name__ == '__main__':
os.remove(DB_LOCATION) # cleanup
engine = create_engine('sqlite:///%s' % DB_LOCATION)
conn = engine.connect()
sqlalchemy_opentracing.init_tracing(tracer)
sqlalchemy_opentracing.register_engine(engine)
span = tracer.start_span('create sample')
# 1. Create a table
metadata = MetaData()
users = Table(
'users',
metadata,
Column('id', Integer, primary_key=True),
Column('name', String),
def init_opentracing_tracer(tracer, **kwargs):
if tracer == OPENTRACING_BASIC:
from basictracer import BasicTracer # noqa
recorder = kwargs.get('recorder')
sampler = kwargs.get('sampler')
opentracing.tracer = BasicTracer(recorder=recorder, sampler=sampler)
elif tracer == OPENTRACING_INSTANA:
import instana # noqa
elif tracer == OPENTRACING_LIGHTSTEP:
import lightstep
# Get Lightstep specific config vars
component_name = kwargs.pop(
'component_name',
os.environ.get('OPENTRACING_LIGHTSTEP_COMPONENT_NAME'))
access_token = kwargs.pop(
'access_token',
os.environ.get('OPENTRACING_LIGHTSTEP_ACCESS_TOKEN'))
collector_host = kwargs.pop(
'collector_host',
os.environ.get('OPENTRACING_LIGHTSTEP_COLLECTOR_HOST',
'collector.lightstep.com'))
collector_port = kwargs.pop(
'collector_port',
int(os.environ.get('OPENTRACING_LIGHTSTEP_COLLECTOR_PORT', 443)))
verbosity = kwargs.pop(
'verbosity',
int(os.environ.get('OPENTRACING_LIGHTSTEP_VERBOSITY', 0)))
scheme = kwargs.pop(
'collector_scheme',
os.environ.get('OPENTRACING_LIGHTSTEP_COLLECTOR_SCHEME', 'https'))
if not access_token:
logger.warning(
'Initializing LightStep tracer with no access_token!')
collector_encryption = "tls"
if scheme == "http":
collector_encryption = "none"
if 'collector_encryption' in kwargs:
collector_encryption = kwargs.pop('collector_encryption',
collector_encryption)
opentracing.tracer = lightstep.Tracer(
component_name=component_name,
access_token=access_token,
collector_host=collector_host,
collector_port=collector_port,
collector_encryption=collector_encryption,
verbosity=verbosity,
**kwargs)
elif tracer == OPENTRACING_JAEGER:
from jaeger_client import Config
service_name = kwargs.pop(
'service_name', os.environ.get('OPENTRACING_JAEGER_SERVICE_NAME'))
config = kwargs.pop('config', {})
jaeger_config = Config(config=config, service_name=service_name)
opentracing.tracer = jaeger_config.initialize_tracer()
else:
opentracing.tracer = opentracing.Tracer()
return opentracing.tracer
def init_lightstep_tracer(component_name):
return lightstep.Tracer(component_name=component_name,
access_token='{your_access_token}')
