/** * Initialize sharding tracer. * * @param tracer opentracing tracer */ public static void init(final Tracer tracer) { if (!GlobalTracer.isRegistered()) { GlobalTracer.register(tracer); } }
@Override public boolean configure(FeatureContext context) { if (!GlobalTracer.isRegistered()) { LOGGER.warning(LocalizationMessages.OPENTRACING_TRACER_NOT_REGISTERED()); } switch (context.getConfiguration().getRuntimeType()) { case CLIENT: context.register(OpenTracingClientRequestFilter.class).register(OpenTracingClientResponseFilter.class); break; case SERVER: context.register(new OpenTracingApplicationEventListener(verbosity)); } return true; }
@PostConstruct public void registerToGlobalTracer() { /** * Tracer registered in GlobalTracer should be the same as the tracer bean. * There can be {@link org.springframework.beans.factory.config.BeanPostProcessor}'s which * alters tracer bean, therefore tracer registered to GlobalTracer should be autowired. */ if (!GlobalTracer.isRegistered()) { GlobalTracer.register(tracer); } }
/** * Initialize sharding tracer. * * @param tracer opentracing tracer */ public static void init(final Tracer tracer) { if (!GlobalTracer.isRegistered()) { GlobalTracer.register(tracer); } }
/** * Register a {@link Tracer} to back the behaviour of the {@link #get() global tracer}. * <p> * Registration is a one-time operation, attempting to call it more often will result in a runtime exception. * <p> * Every application intending to use the global tracer is responsible for registering it once * during its initialization. * * @param tracer Tracer to use as global tracer. * @throws RuntimeException if there is already a current tracer registered */ public static synchronized void register(final Tracer tracer) { if (tracer == null) { throw new NullPointerException("Cannot register GlobalTracer <null>."); } if (tracer instanceof GlobalTracer) { LOGGER.log(Level.FINE, "Attempted to register the GlobalTracer as delegate of itself."); return; // no-op } if (isRegistered() && !GlobalTracer.tracer.equals(tracer)) { throw new IllegalStateException("There is already a current global Tracer registered."); } GlobalTracer.tracer = tracer; }
@Override public void contextInitialized(ServletContextEvent sce) { ServletContext servletContext = sce.getServletContext(); String skipParameter = servletContext.getInitParameter("skipOpenTracingResolver"); if (skipParameter != null && Boolean.parseBoolean(skipParameter)) { logger.info("Skipping the OpenTracing TracerResolver. " + "Your application is expected to set a tracer to GlobalTracer explicitly."); return; } if (GlobalTracer.isRegistered()) { logger.info("A Tracer is already registered at the GlobalTracer. Skipping resolution via TraceResolver."); } Tracer tracer = TracerResolver.resolveTracer(); if (tracer != null) { logger.info(String.format("Registering resolved tracer %s to GlobalTracer.", tracer.getClass().getCanonicalName())); GlobalTracer.register(tracer); } else { logger.info("No Tracerresolver found on classpath!"); } }
public Tracer getTracer() { Tracer tracer; if (GlobalTracer.isRegistered()) { log.warn("GlobalTracer is already registered. For consistency it is best practice to provide " + "a Tracer bean instead of manually registering it with the GlobalTracer");
@Override public void update(Class<?> type, String method, long duration, TimeUnit unit) { if (GlobalTracer.isRegistered() && reportContextSwitchesFor(type)) { String operationName = type.getSimpleName() + "." + method; long finishedMicros = System.currentTimeMillis() * 1000; long startTimestampMicros = finishedMicros - unit.toMicros(duration); Span span = GlobalTracer.get().buildSpan(operationName).withStartTimestamp(startTimestampMicros).start(); try { if ("createContextSnapshot".equals(method)) { span.log("New context snapshot created"); span.log(singletonMap(LOG_FIELD_THREAD, Thread.currentThread().getName())); } else if ("reactivate".equals(method)) { span.log("Context snapshot reactivated"); span.log(singletonMap(LOG_FIELD_THREAD, Thread.currentThread().getName())); } } finally { span.finish(finishedMicros); } } }
private static void mainRun(BindPortFutures portFutures) { try { initAuthorizer(); initPoolManager(portFutures); if (_settings.getTracingEnable() && !GlobalTracer.isRegistered()) { initTracer(); } initWorkManager(portFutures); } catch (Exception e) { System.err.println( "org.batfish.coordinator: Initialization of a helper failed: " + Throwables.getStackTraceAsString(e)); System.exit(1); } // sleep indefinitely, in 10 minute chunks try { while (true) { Thread.sleep(10 * 60 * 1000); // 10 minutes _logger.info("Still alive .... waiting for work to show up\n"); } } catch (Exception ex) { String stackTrace = Throwables.getStackTraceAsString(ex); System.err.println(stackTrace); } } }
@Override public void contextInitialized(ServletContextEvent sce) { if (GlobalTracer.isRegistered()) { TracingLogger.ROOT_LOGGER.alreadyRegistered(); return; } // an application has the option to provide a TracerFactory Tracer tracer = TracerResolver.resolveTracer(); if (null == tracer) { String serviceName = sce.getServletContext().getInitParameter(SMALLRYE_OPENTRACING_SERVICE_NAME); if (null == serviceName || serviceName.isEmpty()) { // this should really not happen, as this is set by the deployment processor TracingLogger.ROOT_LOGGER.noServiceName(); tracer = NoopTracerFactory.create(); } else { sce.getServletContext().setAttribute(SMALLRYE_OPENTRACING_TRACER_MANAGED, true); tracer = Configuration.fromEnv(serviceName).getTracer(); } } TracingLogger.ROOT_LOGGER.registeringTracer(tracer.getClass().getName()); sce.getServletContext().setAttribute(SMALLRYE_OPENTRACING_TRACER, tracer); addJaxRsIntegration(sce.getServletContext(), tracer); TracingLogger.ROOT_LOGGER.initializing(tracer.toString()); }
if (GlobalTracer.isRegistered() && registerTracing) { clientBuilder.register(ClientTracingFeature.class);
@AroundInvoke public Object wrap(InvocationContext ctx) throws Exception { if (!GlobalTracer.isRegistered()) { log.fine("GlobalTracer is not registered. Skipping."); return ctx.proceed();
if (_settings.getTracingEnable() && !GlobalTracer.isRegistered()) { initTracer();
if (io.opentracing.util.GlobalTracer.isRegistered()) { return logResolved(io.opentracing.util.GlobalTracer.get());
protected void initTracer() { synchronized (SYNC) { if (tracer == null) { if (!GlobalTracer.isRegistered()) { boolean triggeringState = Rule.isTriggeringEnabled(); if (!allowInstrumentedTracer() && triggeringState) {
public XioTracing(TracingConfig config) { name = config.getApplicationName(); TracingConfig.TracingType type = config.getType(); switch (type) { case ZIPKIN: String zipkinUrl = config.getZipkinUrl(); float samplingRate = config.getZipkinSamplingRate(); Tracing tracing = buildZipkinTracing(this.name, zipkinUrl, samplingRate); if (tracing != null) { tracer = BraveTracer.create(tracing); } break; case DATADOG: if (GlobalTracer.isRegistered()) { tracer = GlobalTracer.get(); } else { tracer = new DDTracer(); GlobalTracer.register(tracer); } break; } log.info("Configured tracer type: {}", type.toString()); }
private static void mainRunWorkService() { if (_mainSettings.getTracingEnable() && !GlobalTracer.isRegistered()) { initTracer();
public void run(List<String> initialCommands) { if (_settings.getTracingEnable() && !GlobalTracer.isRegistered()) { initTracer();