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 test_should_sample(self):
from opencensus.trace.samplers import always_on
sampler = always_on.AlwaysOnSampler()
should_sample = sampler.should_sample
self.assertTrue(should_sample)
def init_app(self, app):
self.app = app
# get settings from app config
settings = self.app.config.get('OPENCENSUS', {})
settings = settings.get('TRACE', {})
if self.sampler is None:
self.sampler = settings.get('SAMPLER', None) or \
always_on.AlwaysOnSampler()
if isinstance(self.sampler, six.string_types):
self.sampler = configuration.load(self.sampler)
if self.exporter is None:
self.exporter = settings.get('EXPORTER', None) or \
print_exporter.PrintExporter()
if isinstance(self.exporter, six.string_types):
self.exporter = configuration.load(self.exporter)
if self.propagator is None:
self.propagator = settings.get('PROPAGATOR', None) or \
trace_context_http_header_format.TraceContextPropagator()
if isinstance(self.propagator, six.string_types):
self.propagator = configuration.load(self.propagator)
self.blacklist_paths = settings.get(BLACKLIST_PATHS,
self.blacklist_paths)
self.blacklist_hostnames = settings.get(BLACKLIST_HOSTNAMES, None)
self.setup_trace()
def test_tracer(self):
import json
from opencensus.trace import tracer as tracer_module
from opencensus.trace.samplers import always_on
from opencensus.trace.exporters import file_exporter
from opencensus.trace.propagation import google_cloud_format
trace_id = 'f8739df974a4481f98748cd92b27177d'
span_id = '6e0c63257de34c92'
trace_option = 1
trace_header = '{}/{};o={}'.format(trace_id, span_id, trace_option)
sampler = always_on.AlwaysOnSampler()
exporter = file_exporter.FileExporter()
propagator = google_cloud_format.GoogleCloudFormatPropagator()
span_context = propagator.from_header(header=trace_header)
tracer = tracer_module.Tracer(
span_context=span_context,
sampler=sampler,
exporter=exporter,
propagator=propagator
)
with tracer.span(name='root_span') as root:
func_to_trace()
parent_span_id = root.span_id
with root.span(name='child_span'):
func_to_trace()
tracer.finish()
file = open(file_exporter.DEFAULT_FILENAME, 'r')
trace_json = json.loads(file.read())
spans = trace_json.get('spans')
self.assertEqual(trace_json.get('traceId'), trace_id)
self.assertEqual(len(spans), 2)
self.assertSetEqual(
{ss['displayName']['value'] for ss in spans},
{'child_span', 'root_span'})
for span in spans:
if span['displayName']['value'] == 'root_span':
self.assertEqual(span['parentSpanId'], span_id)
self.assertEqual(span['childSpanCount'], 1)
else:
self.assertEqual(span['displayName']['value'], 'child_span')
self.assertEqual(span['parentSpanId'], parent_span_id)
self.assertEqual(span['childSpanCount'], 0)
def serve():
sampler = always_on.AlwaysOnSampler()
exporter = stackdriver_exporter.StackdriverExporter()
tracer_interceptor = server_interceptor.OpenCensusServerInterceptor(
sampler, exporter)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
interceptors=(tracer_interceptor, ))
hello_world_pb2_grpc.add_GreeterServicer_to_server(HelloWorld(), server)
server.add_insecure_port('[::]:50051')
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def _instance(self):
sampler = always_on.AlwaysOnSampler()
exporter = print_exporter.PrintExporter(
transport=background_thread.BackgroundThreadTransport)
# exporter = stackdriver_exporter.StackdriverExporter(project_id="")
tracer_interceptor = server_interceptor.OpenCensusServerInterceptor(
sampler, exporter)
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=self.max_workers),
interceptors=(tracer_interceptor, ))
ouroboros_pb2_grpc.add_OuroborosServicer_to_server(
OuroborosServicer(), server)
server.add_insecure_port(f"{self.host}:{self.port}")
return server
def __init__(self, app, sampler=None, reporter=None, propagator=None):
if sampler is None:
sampler = always_on.AlwaysOnSampler()
if reporter is None:
reporter = print_reporter.PrintReporter()
if propagator is None:
propagator = google_cloud_format.GoogleCloudFormatPropagator()
self.app = app
self.sampler = sampler
self.reporter = reporter
self.propagator = propagator
self.setup_trace()
def main():
# Setup and start the gRPC server with the OpenCensus integration/interceptor
tracer_interceptor = server_interceptor.OpenCensusServerInterceptor(
always_on.AlwaysOnSampler(), stackdriverExporter)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
interceptors=(tracer_interceptor, ))
proto.add_FetchServicer_to_server(CapitalizeServer(), server)
server.add_insecure_port('[::]:9778')
server.start()
try:
while True:
time.sleep(60 * 60)
except KeyboardInterrupt:
server.stop(0)
def serve_grpc_binary(port=pb2.PYTHON_GRPC_BINARY_PROPAGATION_PORT):
"""Run the GRPC/binary server, shut down on exiting context."""
interceptor = server_interceptor.OpenCensusServerInterceptor(
always_on.AlwaysOnSampler(),
trace_exporter.TraceExporter(SERVICE_NAME))
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=GRPC_TPE_WORKERS),
interceptors=(interceptor, ))
pb2_grpc.add_TestExecutionServiceServicer_to_server(
GRPCBinaryTestServer(), server)
server.add_insecure_port('[::]:{}'.format(port))
try:
server.start()
yield server
finally:
server.stop(0)
logger.debug("Shut down grpc server")
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 __init__(self,
app,
blacklist_paths=None,
sampler=None,
exporter=None,
propagator=None):
if sampler is None:
sampler = always_on.AlwaysOnSampler()
if exporter is None:
exporter = print_exporter.PrintExporter()
if propagator is None:
propagator = google_cloud_format.GoogleCloudFormatPropagator()
self.app = app
self.blacklist_paths = blacklist_paths
self.sampler = sampler
self.exporter = exporter
self.propagator = propagator
self.setup_trace()
def test_constructor_explicit(self):
from opencensus.trace import span_context
from opencensus.trace.reporters import print_reporter
from opencensus.trace.samplers import always_on
from opencensus.trace.propagation import google_cloud_format
from opencensus.trace.tracer import webapp2_tracer
trace_id = '6e0c63257de34c92bf9efcd03927272e'
span_context = span_context.SpanContext(trace_id=trace_id)
sampler = always_on.AlwaysOnSampler()
reporter = print_reporter.PrintReporter()
propagator = google_cloud_format.GoogleCloudFormatPropagator()
tracer = webapp2_tracer.WebApp2Tracer(span_context=span_context,
sampler=sampler,
reporter=reporter,
propagator=propagator)
self.assertEqual(tracer.span_context, span_context)
self.assertEqual(tracer.sampler, sampler)
self.assertEqual(tracer.reporter, reporter)
self.assertEqual(tracer.propagator, propagator)
def __init__(self, get_response=None):
self.get_response = get_response
settings = getattr(django.conf.settings, 'OPENCENSUS', {})
settings = settings.get('TRACE', {})
self.sampler = settings.get('SAMPLER', None) or \
always_on.AlwaysOnSampler()
if isinstance(self.sampler, six.string_types):
self.sampler = configuration.load(self.sampler)
self.exporter = settings.get('EXPORTER', None) or \
print_exporter.PrintExporter()
if isinstance(self.exporter, six.string_types):
self.exporter = configuration.load(self.exporter)
self.propagator = settings.get('PROPAGATOR', None) or \
trace_context_http_header_format.TraceContextPropagator()
if isinstance(self.propagator, six.string_types):
self.propagator = configuration.load(self.propagator)
self.blacklist_paths = settings.get(BLACKLIST_PATHS, None)
self.blacklist_hostnames = settings.get(BLACKLIST_HOSTNAMES, None)
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 __init__(self,
span_context=None,
sampler=None,
exporter=None,
propagator=None):
if span_context is None:
span_context = SpanContext()
if sampler is None:
sampler = always_on.AlwaysOnSampler()
if exporter is None:
exporter = print_exporter.PrintExporter()
if propagator is None:
propagator = google_cloud_format.GoogleCloudFormatPropagator()
self.span_context = span_context
self.sampler = sampler
self.exporter = exporter
self.propagator = propagator
self.tracer = self.get_tracer()
self.store_tracer()
def __init__(self,
span_context=None,
sampler=None,
exporter=None,
propagator=None):
if span_context is None:
span_context = SpanContext()
if sampler is None:
sampler = always_on.AlwaysOnSampler()
if exporter is None:
exporter = print_exporter.PrintExporter()
if propagator is None:
propagator = \
trace_context_http_header_format.TraceContextPropagator()
self.span_context = span_context
self.sampler = sampler
self.exporter = exporter
self.propagator = propagator
self.tracer = self.get_tracer()
self.store_tracer()
import sys
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 always_on
# 1a. Setup the exporter
ze = ZipkinExporter(service_name="python-quickstart",
host_name='localhost',
port=9411,
endpoint='/api/v2/spans')
# 1b. Set the tracer to use the exporter
# 2. Configure 100% sample rate, otherwise, few traces will be sampled.
# 3. Get the global singleton Tracer object
tracer = Tracer(exporter=ze, sampler=always_on.AlwaysOnSampler())
def main():
# 4. Create a scoped span. The span will close at the end of the block.
with tracer.span(name="main") as span:
for i in range(0, 10):
doWork()
def doWork():
# 5. Start another span. Because this is within the scope of the "main" span,
# this will automatically be a child span.
with tracer.span(name="doWork") as span:
print("doing busy work")
try:
time.sleep(0.1)
except:
try:
if "DISABLE_PROFILER" in os.environ:
raise KeyError()
else:
logger.info("Profiler enabled.")
initStackdriverProfiling()
except KeyError:
logger.info("Profiler disabled.")
tracer = None
try:
if "DISABLE_TRACING" in os.environ:
raise KeyError()
else:
logger.info("Tracing enabled.")
sampler = always_on.AlwaysOnSampler()
exporter = stackdriver_exporter.StackdriverExporter(
project_id=os.environ.get('GCP_PROJECT_ID'),
transport=AsyncTransport)
tracer_interceptor = server_interceptor.OpenCensusServerInterceptor(
sampler, exporter)
tracer = Tracer(exporter=exporter)
except (KeyError, DefaultCredentialsError):
logger.info("Tracing disabled.")
tracer_interceptor = server_interceptor.OpenCensusServerInterceptor()
try:
if "DISABLE_DEBUGGER" in os.environ:
raise KeyError()
else:
def __init__(self, transporter):
self.transporter = transporter
self.exporter = exporter.CustomExporter(transporter)
config_integration.trace_integrations(['httplib'])
self.tracer = Tracer(exporter=self.exporter,
sampler=always_on.AlwaysOnSampler())
# 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 opencensus.trace import print_exporter
from opencensus.trace.samplers import always_on
from opencensus.trace.propagation import google_cloud_format
DEFAULT_PYRAMID_TRACER_CONFIG = {
'SAMPLER': always_on.AlwaysOnSampler(),
'EXPORTER': print_exporter.PrintExporter(),
'PROPAGATOR': google_cloud_format.GoogleCloudFormatPropagator()
}
DEFAULT_PYRAMID_TRACER_PARAMS = {
# https://cloud.google.com/appengine/docs/flexible/python/
# how-instances-are-managed#health_checking
'BLACKLIST_PATHS': ['_ah/health'],
}
class PyramidTraceSettings(object):
def __init__(self, registry):
self.settings = registry.settings.get('OPENCENSUS_TRACE',
DEFAULT_PYRAMID_TRACER_CONFIG)
