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)