def hello_world(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("server_span"): return "Hello World!"
def create_trace_config( url_filter: _UrlFilterT = None, request_hook: _RequestHookT = None, response_hook: _ResponseHookT = None, tracer_provider: TracerProvider = None, ) -> aiohttp.TraceConfig: """Create an aiohttp-compatible trace configuration. One span is created for the entire HTTP request, including initial TCP/TLS setup if the connection doesn't exist. By default the span name is set to the HTTP request method. Example usage: .. code:: python import aiohttp from opentelemetry.instrumentation.aiohttp_client import create_trace_config async with aiohttp.ClientSession(trace_configs=[create_trace_config()]) as session: async with session.get(url) as response: await response.text() :param url_filter: A callback to process the requested URL prior to adding it as a span attribute. This can be useful to remove sensitive data such as API keys or user personal information. :param Callable request_hook: Optional callback that can modify span name and request params. :param Callable response_hook: Optional callback that can modify span name and response params. :param tracer_provider: optional TracerProvider from which to get a Tracer :return: An object suitable for use with :py:class:`aiohttp.ClientSession`. :rtype: :py:class:`aiohttp.TraceConfig` """ # `aiohttp.TraceRequestStartParams` resolves to `aiohttp.tracing.TraceRequestStartParams` # which doesn't exist in the aiohttp intersphinx inventory. # Explicitly specify the type for the `request_hook` and `response_hook` param and rtype to work # around this issue. tracer = get_tracer(__name__, __version__, tracer_provider) def _end_trace(trace_config_ctx: types.SimpleNamespace): context_api.detach(trace_config_ctx.token) trace_config_ctx.span.end() async def on_request_start( unused_session: aiohttp.ClientSession, trace_config_ctx: types.SimpleNamespace, params: aiohttp.TraceRequestStartParams, ): if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY): trace_config_ctx.span = None return http_method = params.method.upper() request_span_name = "HTTP {}".format(http_method) trace_config_ctx.span = trace_config_ctx.tracer.start_span( request_span_name, kind=SpanKind.CLIENT, ) if callable(request_hook): request_hook(trace_config_ctx.span, params) if trace_config_ctx.span.is_recording(): attributes = { SpanAttributes.HTTP_METHOD: http_method, SpanAttributes.HTTP_URL: remove_url_credentials( trace_config_ctx.url_filter(params.url) ) if callable(trace_config_ctx.url_filter) else remove_url_credentials(str(params.url)), } for key, value in attributes.items(): trace_config_ctx.span.set_attribute(key, value) trace_config_ctx.token = context_api.attach( trace.set_span_in_context(trace_config_ctx.span) ) inject(params.headers) async def on_request_end( unused_session: aiohttp.ClientSession, trace_config_ctx: types.SimpleNamespace, params: aiohttp.TraceRequestEndParams, ): if trace_config_ctx.span is None: return if callable(response_hook): response_hook(trace_config_ctx.span, params) if trace_config_ctx.span.is_recording(): trace_config_ctx.span.set_status( Status(http_status_to_status_code(int(params.response.status))) ) trace_config_ctx.span.set_attribute( SpanAttributes.HTTP_STATUS_CODE, params.response.status ) _end_trace(trace_config_ctx) async def on_request_exception( unused_session: aiohttp.ClientSession, trace_config_ctx: types.SimpleNamespace, params: aiohttp.TraceRequestExceptionParams, ): if trace_config_ctx.span is None: return if callable(response_hook): response_hook(trace_config_ctx.span, params) if trace_config_ctx.span.is_recording() and params.exception: trace_config_ctx.span.set_status(Status(StatusCode.ERROR)) trace_config_ctx.span.record_exception(params.exception) _end_trace(trace_config_ctx) def _trace_config_ctx_factory(**kwargs): kwargs.setdefault("trace_request_ctx", {}) return types.SimpleNamespace( tracer=tracer, url_filter=url_filter, **kwargs ) trace_config = aiohttp.TraceConfig( trace_config_ctx_factory=_trace_config_ctx_factory ) trace_config.on_request_start.append(on_request_start) trace_config.on_request_end.append(on_request_end) trace_config.on_request_exception.append(on_request_exception) return trace_config
def setUp(self): super().setUp() PymemcacheInstrumentor().instrument() # pylint: disable=protected-access self.tracer = get_tracer(__name__)
def _get_tracer(engine, tracer_provider=None): return trace.get_tracer( _normalize_vendor(engine.name), __version__, tracer_provider=tracer_provider, )
def _instrumented_requests_call( method: str, url: str, call_wrapped, get_or_create_headers ): if context.get_value("suppress_instrumentation") or context.get_value( _SUPPRESS_REQUESTS_INSTRUMENTATION_KEY ): return call_wrapped() # See # https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-client method = method.upper() span_name = "" if name_callback is not None: span_name = name_callback(method, url) if not span_name or not isinstance(span_name, str): span_name = get_default_span_name(method) labels = {} labels["http.method"] = method labels["http.url"] = url with get_tracer( __name__, __version__, tracer_provider ).start_as_current_span(span_name, kind=SpanKind.CLIENT) as span: exception = None if span.is_recording(): span.set_attribute("http.method", method) span.set_attribute("http.url", url) headers = get_or_create_headers() inject(headers) token = context.attach( context.set_value(_SUPPRESS_REQUESTS_INSTRUMENTATION_KEY, True) ) try: result = call_wrapped() # *** PROCEED except Exception as exc: # pylint: disable=W0703 exception = exc result = getattr(exc, "response", None) finally: context.detach(token) if isinstance(result, Response): if span.is_recording(): span.set_attribute("http.status_code", result.status_code) span.set_attribute("http.status_text", result.reason) span.set_status( Status(http_status_to_status_code(result.status_code)) ) labels["http.status_code"] = str(result.status_code) if result.raw and result.raw.version: labels["http.flavor"] = ( str(result.raw.version)[:1] + "." + str(result.raw.version)[:-1] ) if span_callback is not None: span_callback(span, result) if exception is not None: raise exception.with_traceback(exception.__traceback__) return result
def get_app(self): tracer = trace.get_tracer(__name__) app = make_app(tracer) return app
# ConsoleSpanExporter(), ) ) # trace.get_tracer_provider().add_span_processor( # SimpleExportSpanProcessor( # ZipkinSpanExporter("rob-j", "http://host.docker.internal:9411/api/v2/spans", encoder=TransportFormat.V2_JSON), # # ZipkinSpanExporter("rob", "http://host.docker.internal:9411/api/v2/spans", encoder=TransportFormat.V2_JSON), # # OTLPSpanExporter(endpoint="host.docker.internal:55681", insecure=True, timeout=3), # # ConsoleSpanExporter(), # ) # ) provider = trace.get_tracer_provider() tracer = trace.get_tracer(__name__, "1.1r") with tracer.start_as_current_span("foo") as foo_span: foo_span.add_event("Alpha") foo_span.add_event("boom boom") foo_span.set_attribute("phone", "iphone X") foo_span.set_attribute("beats", "spotify") with tracer.start_as_current_span("bar") as bar_span: bar_span.add_event("Apocalypse") bar_span.set_attribute("sky", "blue") with tracer.start_as_current_span("baz") as baz_span: baz_span.add_event("event 1") baz_span.set_attribute('att1', 'att_val1') eadlwij = 1 # sleep(500)
def hello(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span('test_span'): return "SRE and DevOps work together!!! "
def span_call_child(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("step1") as span1: requests.get("http://jaeger-app-2-srv-2:5555/example6") return "simple call"
def __init__(self, wsgi, name_callback=get_default_span_name): self.wsgi = wsgi self.tracer = trace.get_tracer(__name__, __version__) self.name_callback = name_callback
def __init__(self, wsgi, request_hook=None, response_hook=None): self.wsgi = wsgi self.tracer = trace.get_tracer(__name__, __version__) self.request_hook = request_hook self.response_hook = response_hook
def hello(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("example-request"): requests.get("http://www.example.com") return "hello"
def test_get_tracer(self): """trace.get_tracer should proxy to the global tracer provider.""" trace.get_tracer("foo", "var") self._mock_tracer_provider.get_tracer.assert_called_with("foo", "var")
password=redis_password, decode_responses=True) r.set("msg:hello", "Hello Redis!!!") msg = r.get("msg:hello") # print(msg) except Exception as e: print(e) while True: hello_redis() # redis is picked up by auto-instrumentation random_number = randint(0, 16777215) hex_number = str(hex(random_number)) hex_number = hex_number[2:] printtime = datetime.datetime.now().strftime( "%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" log_dict = {'transactionTime': printtime, 'transactionID': hex_number} tracer = trace.get_tracer( __name__) # create a manual span for a logging operation called "log" with tracer.start_as_current_span("log", kind=SpanKind.SERVER) as span: span.set_attribute("transactionTime", printtime) span.set_attribute("transactionID", hex_number) print(json.dumps(log_dict)) y = round(random(), 1) + .25 sleep(y) # print('Sleeping: ', y)
def _instrumented_open_call( _, request, call_wrapped, get_or_create_headers ): # pylint: disable=too-many-locals if context.get_value("suppress_instrumentation") or context.get_value( _SUPPRESS_HTTP_INSTRUMENTATION_KEY ): return call_wrapped() method = request.get_method().upper() url = request.full_url span_name = "" if name_callback is not None: span_name = name_callback(method, url) if not span_name or not isinstance(span_name, str): span_name = get_default_span_name(method) labels = { "http.method": method, "http.url": url, } with get_tracer( __name__, __version__, tracer_provider ).start_as_current_span(span_name, kind=SpanKind.CLIENT) as span: exception = None if span.is_recording(): span.set_attribute("http.method", method) span.set_attribute("http.url", url) headers = get_or_create_headers() inject(headers) token = context.attach( context.set_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY, True) ) try: result = call_wrapped() # *** PROCEED except Exception as exc: # pylint: disable=W0703 exception = exc result = getattr(exc, "file", None) finally: context.detach(token) if result is not None: code_ = result.getcode() labels["http.status_code"] = str(code_) if span.is_recording(): span.set_attribute("http.status_code", code_) span.set_status(Status(http_status_to_status_code(code_))) ver_ = str(getattr(result, "version", "")) if ver_: labels["http.flavor"] = "{}.{}".format(ver_[:1], ver_[:-1]) if span_callback is not None: span_callback(span, result) if exception is not None: raise exception.with_traceback(exception.__traceback__) return result
def span_example8(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("step1") as span1: time.sleep(1) span_parallel_example8_process1() return "secuencial spans"
def tracer(): trace.set_tracer_provider(TracerProvider()) return trace.get_tracer(__name__)
def span_parallel_example8_process1(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("process1") as span1: span_parallel_example7_process2()
def test_patch_applied_only_once(self): tracer = trace.get_tracer(__name__) self.assertTrue(patch_handler_class(tracer, AsyncHandler)) self.assertFalse(patch_handler_class(tracer, AsyncHandler)) self.assertFalse(patch_handler_class(tracer, AsyncHandler)) unpatch_handler_class(AsyncHandler)
async def span_parallel_example9_process1(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("process1") as span1: time.sleep(1) print("do something")
def test_build(self): builder = SpanBuilder(get_tracer(__name__)) builder.set_as_consumer() builder.set_destination('destination') span = builder.build() self.assertTrue(isinstance(span, Span))
def setUp(self): super().setUp() LoggingInstrumentor().instrument() self.tracer = get_tracer(__name__)
def get_tracer(self): return get_tracer( self._name, instrumenting_library_version=self._version, tracer_provider=self._tracer_provider, )
def request( # type:ignore self, method, url, query_params=None, headers=None, post_params=None, body=None, _preload_content=True, _request_timeout=None, ): headers = {} if headers is None else headers span_attributes = { "http.method": method, "http.url": url, } with get_tracer(__name__, __version__).start_as_current_span( f"External Api Call {self.__class__.__name__}", kind=SpanKind.CLIENT, attributes=span_attributes) as span: try: self.add_client_creds_token_header(headers) if self._tracing_enabled and not _is_instrumentation_suppressed( ): inject(type(headers).__setitem__, headers) with _suppress_further_instrumentation(): response = super().request( # type:ignore method, url, query_params, headers, post_params, body, _preload_content, _request_timeout) _apply_response(span, response) return response except Exception as ex: if is_api_exception(ex) and ex.status in ( HTTPStatus.UNAUTHORIZED, HTTPStatus.FORBIDDEN): # type:ignore logger.warning("Access Denied. Token expired? Retrying.", api_exception=str(ex)) loop = new_event_loop() loop.run_until_complete( self.refresh_client_creds_token(force=True)) self.add_client_creds_token_header(headers) if self._tracing_enabled and not _is_instrumentation_suppressed( ): inject(type(headers).__setitem__, headers) with _suppress_further_instrumentation(): response = super().request( # type:ignore method, url, query_params, headers, post_params, body, _preload_content, _request_timeout) _apply_response(span, response) return response else: logger.exception("Could not call API.", client=self.__class__.__name__) _apply_response(span, ex) raise
# 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 opentelemetry import trace from splunk_otel import start_tracing provider = start_tracing() tracer = trace.get_tracer("simple", "0.1") def main(): with tracer.start_as_current_span( "custom span", kind=trace.SpanKind.INTERNAL ) as span: span.add_event("event1", {"k1": "v1"}) if __name__ == "__main__": main() provider.force_flush() provider.shutdown()
def __init__(self, wsgi): self.wsgi = wsgi self.tracer = trace.get_tracer(__name__, __version__)
def __init__(self, app, span_details_callback=None): self.app = guarantee_single_callable(app) self.tracer = trace.get_tracer(__name__, __version__) self.span_details_callback = (span_details_callback or get_default_span_details)
def get_current_tracer(cls): # type: () -> Tracer """ Get the current tracer from the execution context. Return None otherwise. """ return trace.get_tracer(__name__, __version__)
DatadogExportSpanProcessor( DatadogSpanExporter(agent_url="http://*****:*****@app.route("/server_request") def server_request(): param = request.args.get("param") with tracer.start_as_current_span("server-inner"): if param == "error": raise ValueError("forced server error") return "served: {}".format(param) if __name__ == "__main__": app.run(port=8082)
def _instrumented_requests_call(method: str, url: str, call_wrapped, get_or_create_headers): if context.get_value("suppress_instrumentation") or context.get_value( _SUPPRESS_REQUESTS_INSTRUMENTATION_KEY): return call_wrapped() # See # https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/semantic_conventions/http.md#http-client method = method.upper() span_name = "HTTP {}".format(method) recorder = RequestsInstrumentor().metric_recorder labels = {} labels["http.method"] = method labels["http.url"] = url with get_tracer(__name__, __version__, tracer_provider).start_as_current_span( span_name, kind=SpanKind.CLIENT) as span: exception = None with recorder.record_duration(labels): if span.is_recording(): span.set_attribute("component", "http") span.set_attribute("http.method", method) span.set_attribute("http.url", url) headers = get_or_create_headers() propagators.inject(type(headers).__setitem__, headers) token = context.attach( context.set_value(_SUPPRESS_REQUESTS_INSTRUMENTATION_KEY, True)) try: result = call_wrapped() # *** PROCEED except Exception as exc: # pylint: disable=W0703 exception = exc setattr( exception, EXCEPTION_STATUS_FIELD, _exception_to_canonical_code(exception), ) result = getattr(exc, "response", None) finally: context.detach(token) if result is not None: if span.is_recording(): span.set_attribute("http.status_code", result.status_code) span.set_attribute("http.status_text", result.reason) span.set_status( Status( http_status_to_canonical_code( result.status_code))) labels["http.status_code"] = str(result.status_code) labels["http.status_text"] = result.reason if result.raw and result.raw.version: labels["http.flavor"] = (str(result.raw.version)[:1] + "." + str(result.raw.version)[:-1]) if span_callback is not None: span_callback(span, result) if exception is not None: raise exception.with_traceback(exception.__traceback__) return result