def __init__(self, get_response=None):
settings = getattr(django.conf.settings, 'OPENCENSUS', {})
settings = settings.get('TRACE', {})
self.sampler = (settings.get('SAMPLER', None)
or samplers.ProbabilitySampler())
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.excludelist_paths = settings.get(EXCLUDELIST_PATHS, None)
self.excludelist_hostnames = settings.get(EXCLUDELIST_HOSTNAMES, None)
if django.VERSION >= (2, ): # pragma: NO COVER
connection.execute_wrappers.append(_trace_db_call)
super().__init__(get_response)
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 samplers.ProbabilitySampler())
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)
self.explain_mode = settings.get('EXPLAIN', None)
logger.debug(f"OpenCensus Exporter: {self.exporter}")
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 samplers.ProbabilitySampler())
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_should_sample_greater(self):
trace_id = 'f8739df974a4481f98748cd92b27177d'
mock_context = mock.Mock()
mock_context.trace_id = trace_id
mock_context.trace_options.get_enabled.return_value = False
sampler = samplers.ProbabilitySampler()
self.assertFalse(sampler.should_sample(mock_context))
def test_should_sample_short_circuit(self):
trace_id = 'ffffffffffffffffffffffffffffffff'
mock_context = mock.Mock()
mock_context.trace_id = trace_id
mock_context.trace_options.get_enabled.return_value = True
sampler = samplers.ProbabilitySampler()
self.assertTrue(sampler.should_sample(mock_context))
def test_should_sample_high_traceid(self):
trace_id = '000000000000000000068db8bac710cc'
mock_context = mock.Mock()
mock_context.trace_id = trace_id
mock_context.trace_options.get_enabled.return_value = False
sampler = samplers.ProbabilitySampler()
self.assertFalse(sampler.should_sample(mock_context))
def initialize_opencensus(config, flask_app):
if config.opencensus_enable:
agent = config.opencensus_agent
print(f"OpenCensus enabled and reporting to {agent} using gRPC")
exporter = ocagent_trace_exporter.TraceExporter(service_name=SERVICE_NAME, endpoint=agent)
sampler = samplers.ProbabilitySampler(rate=config.opencensus_sample_rate)
config_integration.trace_integrations(['sqlalchemy'])
FlaskMiddleware(flask_app, exporter=exporter, sampler=sampler)
flask_app.wsgi_app = SentryIoContextMiddleware(flask_app.wsgi_app)
flask.before_render_template.connect(render_template_start, flask_app)
flask.template_rendered.connect(render_template_end, flask_app)
def run_app():
settings = {
'OPENCENSUS': {
'TRACE': {
'EXPORTER': print_exporter.PrintExporter(),
'SAMPLER': samplers.ProbabilitySampler(rate=1),
}
}
}
app = main({}, **settings)
server = make_server('localhost', 8080, app)
server.serve_forever()
def test_should_sample_low_traceid(self):
trace_id = '000000000000000000068db8bac710cb'
mock_context = mock.Mock()
mock_context.trace_id = trace_id
mock_context.trace_options.get_enabled.return_value = False
sampler = samplers.ProbabilitySampler()
self.assertTrue(sampler.should_sample(mock_context))
# Check that we only check the last 8 bytes
trace_id2 = 'ffffffffffffffff00068db8bac710cb'
mock_context.trace_id = trace_id2
self.assertTrue(sampler.should_sample(mock_context))
def get_tracer_sampler():
global _tracer_sampler
if _tracer_sampler is None:
settings_ = getattr(settings, 'OPENCENSUS', {})
settings_ = settings_.get('TRACE', {})
_tracer_sampler = settings_.get('SAMPLER', None) or \
samplers.ProbabilitySampler()
if isinstance(_tracer_sampler, str):
_tracer_sampler = configuration.load(_tracer_sampler)
return _tracer_sampler
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 = samplers.ProbabilitySampler()
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()
app.register_blueprint(justice_counts_control, url_prefix="/justice_counts")
if environment.in_gcp():
SQLAlchemyEngineManager.init_engines_for_server_postgres_instances()
# Export traces and metrics to stackdriver if running in GCP
if environment.in_gcp():
monitoring.register_stackdriver_exporter()
trace_exporter = stackdriver_trace.StackdriverExporter(
project_id=metadata.project_id(), transport=AsyncTransport
)
trace_sampler = trace.CompositeSampler(
{
"/direct/process_job": samplers.AlwaysOnSampler(),
# There are a lot of scraper requests, so they can use the default rate of 1 in 10k.
"/scraper/": samplers.ProbabilitySampler(),
"/scrape_aggregate_reports/": samplers.ProbabilitySampler(),
},
# For other requests, trace 1 in 20.
default_sampler=samplers.ProbabilitySampler(rate=0.05),
)
else:
trace_exporter = file_exporter.FileExporter(file_name="traces")
trace_sampler = samplers.AlwaysOnSampler()
middleware = FlaskMiddleware(
app,
excludelist_paths=["metadata", "computeMetadata"], # Don't trace metadata requests
sampler=trace_sampler,
exporter=trace_exporter,
propagator=google_cloud_format.GoogleCloudFormatPropagator(),
def test_constructor_invalid(self):
with self.assertRaises(ValueError):
samplers.ProbabilitySampler(rate=2)
PROJECT = os.environ.get('GCLOUD_PROJECT_PYTHON')
# MySQL settings
MYSQL_PASSWORD = os.environ.get('SYSTEST_MYSQL_PASSWORD')
# PostgreSQL settings
POSTGRES_PASSWORD = os.environ.get('SYSTEST_POSTGRES_PASSWORD')
# hello_world_server location
HELLO_WORLD_HOST_PORT = 'localhost:50051'
app = flask.Flask(__name__)
# Enable tracing, configure the trace params, send traces to Stackdriver Trace
exporter = stackdriver_exporter.StackdriverExporter()
sampler = samplers.ProbabilitySampler(rate=1)
middleware = FlaskMiddleware(app, exporter=exporter, sampler=sampler)
config_integration.trace_integrations(INTEGRATIONS)
# cache of (stub_cls, hostport) -> grpc stub
_stub_cache = {}
@app.route('/')
def hello():
return 'Hello world!'
@app.route('/requests')
def trace_requests():
response = requests.get('http://www.google.com')
app.register_blueprint(backup_manager_blueprint, url_prefix='/backup_manager')
app.register_blueprint(dataflow_monitor_blueprint, url_prefix='/dataflow_monitor')
app.register_blueprint(validation_manager_blueprint, url_prefix='/validation_manager')
app.register_blueprint(calculation_data_storage_manager_blueprint, url_prefix='/calculation_data_storage_manager')
app.register_blueprint(reporting_endpoint_blueprint, url_prefix='/reporting')
app.register_blueprint(export_blueprint, url_prefix='/export')
if environment.in_gae():
SQLAlchemyEngineManager.init_engines_for_server_postgres_instances()
# Export traces and metrics to stackdriver if running on GAE
if environment.in_gae():
monitoring.register_stackdriver_exporter()
trace_exporter = stackdriver_trace.StackdriverExporter(
project_id=metadata.project_id(), transport=AsyncTransport)
trace_sampler = samplers.ProbabilitySampler(rate=0.05) # Default is 1 in 10k, trace 1 in 20 instead
else:
trace_exporter = file_exporter.FileExporter(file_name='traces')
trace_sampler = samplers.AlwaysOnSampler()
middleware = FlaskMiddleware(
app,
blacklist_paths=['metadata'], # Don't trace metadata requests
sampler=trace_sampler,
exporter=trace_exporter,
propagator=google_cloud_format.GoogleCloudFormatPropagator())
config_integration.trace_integrations([
# TODO(#4283): The 'google_cloud_clientlibs' integration is currently not compatible with the 'proto-plus' objects
# used by the 2.0.0 versions of the client libraries. Investigate best way to hydrate spans in traces for these
# calls in the future.
'google_cloud_clientlibs',
def test_constructor_valid(self):
rate = 0.8
sampler = samplers.ProbabilitySampler(rate=rate)
self.assertEqual(sampler.rate, rate)
def test_constructor_default(self):
sampler = samplers.ProbabilitySampler()
self.assertEqual(sampler.rate, samplers.DEFAULT_SAMPLING_RATE)
