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_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 __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 link_from_headers(cls, headers):
# type: (Dict[str, str]) -> None
"""
Given a dictionary, extracts the context and links the context to the current tracer.
:param headers: A key value pair dictionary
:type headers: dict
"""
ctx = trace_context_http_header_format.TraceContextPropagator().from_headers(headers)
current_span = cls.get_current_span()
current_span.add_link(Link(ctx.trace_id, ctx.span_id))
def get_tracer_propagator():
global _tracer_propagator
if _tracer_propagator is None:
settings_ = getattr(settings, 'OPENCENSUS', {})
settings_ = settings_.get('TRACE', {})
_tracer_propagator = settings_.get('PROPAGATOR', None) or \
trace_context_http_header_format.TraceContextPropagator()
if isinstance(_tracer_propagator, str):
_tracer_propagator = configuration.load(_tracer_propagator)
return _tracer_propagator
def __init__(self, span=None, name="span", **kwargs):
# type: (Optional[Span], Optional[str], Any) -> None
"""
If a span is not passed in, creates a new tracer. If the instrumentation key for Azure Exporter is given, will
configure the azure exporter else will just create a new tracer.
:param span: The OpenCensus span to wrap
:type span: :class: opencensus.trace.Span
:param name: The name of the OpenCensus span to create if a new span is needed
:type name: str
:keyword SpanKind kind: The span kind of this span.
:keyword links: The list of links to be added to the span.
:paramtype links: list[~azure.core.tracing.Link]
"""
tracer = self.get_current_tracer()
value = kwargs.pop('kind', None)
kind = (
OpenCensusSpanKind.CLIENT
if value == SpanKind.CLIENT else OpenCensusSpanKind.CLIENT
if value == SpanKind.PRODUCER else # No producer in opencensus
OpenCensusSpanKind.SERVER if value == SpanKind.SERVER else
OpenCensusSpanKind.CLIENT if value ==
SpanKind.CONSUMER else # No consumer in opencensus
OpenCensusSpanKind.UNSPECIFIED if value ==
SpanKind.INTERNAL else # No internal in opencensus
OpenCensusSpanKind.UNSPECIFIED if value ==
SpanKind.UNSPECIFIED else None) # type: SpanKind
if value and kind is None:
raise ValueError(
"Kind {} is not supported in OpenCensus".format(value))
links = kwargs.pop('links', None)
self._span_instance = span or tracer.start_span(name=name, **kwargs)
if kind is not None:
self._span_instance.span_kind = kind
if links:
try:
for link in links:
ctx = trace_context_http_header_format.TraceContextPropagator(
).from_headers(link.headers)
self._span_instance.add_link(
Link(trace_id=ctx.trace_id,
span_id=ctx.span_id,
attributes=link.attributes))
except AttributeError:
# we will just send the links as is if it's not ~azure.core.tracing.Link without any validation
# assuming user knows what they are doing.
self._span_instance.links = links
def get_opencensus_values():
"""
Return the OpenCensus Trace and Span IDs if Span ID is set in the
OpenCensus execution context.
"""
if execution_context:
span_ctx = execution_context.get_opencensus_tracer().span_context
span_id = span_ctx.span_id
if span_id:
# Insert the W3C TraceContext generated
w3C_trace_ctx = trace_context_http_header_format.TraceContextPropagator(
)
return w3C_trace_ctx.to_headers(span_ctx)
else:
raise ImportError('opencensus is not installed.')
return {}
def __init__(
self,
app: ASGIApp,
excludelist_paths=None,
excludelist_hostnames=None,
sampler=None,
exporter=None,
propagator=None,
) -> None:
super().__init__(app)
self.app = app
self.excludelist_paths = excludelist_paths
self.excludelist_hostnames = excludelist_hostnames
self.sampler = sampler or samplers.AlwaysOnSampler()
self.exporter = exporter or print_exporter.PrintExporter()
self.propagator = (
propagator
or trace_context_http_header_format.TraceContextPropagator())
def initialize_tracer(request: 'flask.Request') -> tracer.Tracer:
if TRACE_PROPAGATE == "google":
propagator = google_cloud_format.GoogleCloudFormatPropagator()
else:
propagator = trace_context_http_header_format.TraceContextPropagator()
if TRACE_EXPORTER == "stackdriver":
exporter = trace_exporter.StackdriverExporter(transport=AsyncTransport)
sampler = samplers.AlwaysOnSampler()
elif TRACE_EXPORTER == "log":
exporter = logging_exporter.LoggingExporter(
handler=py_logging.NullHandler(), transport=AsyncTransport)
sampler = samplers.AlwaysOnSampler()
elif TRACE_EXPORTER == "stdout":
exporter = print_exporter.PrintExporter(transport=AsyncTransport)
sampler = samplers.AlwaysOnSampler()
else:
exporter = print_exporter.PrintExporter(transport=AsyncTransport)
sampler = samplers.AlwaysOffSampler()
span_context = propagator.from_headers(request.headers)
return tracer.Tracer(exporter=exporter,
sampler=sampler,
propagator=propagator,
span_context=span_context)
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 __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()
#
# 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, samplers
from opencensus.trace.propagation import trace_context_http_header_format
DEFAULT_PYRAMID_TRACER_CONFIG = {
'SAMPLER': samplers.AlwaysOnSampler(),
'EXPORTER': print_exporter.PrintExporter(),
'PROPAGATOR': trace_context_http_header_format.TraceContextPropagator(),
# 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', {})
self.settings = self.settings.get('TRACE',
DEFAULT_PYRAMID_TRACER_CONFIG)
_set_default_configs(self.settings, DEFAULT_PYRAMID_TRACER_CONFIG)
def __getattr__(self, attr):
def __init__(self, span=None):
self.span = span
self.propagator = (
trace_context_http_header_format.TraceContextPropagator()
)
