Examples with DefaultTracer com.newrelic.agent.tracers.DefaultTracer used on opensource projects

Example 36 with DefaultTracer

use of com.newrelic.agent.tracers.DefaultTracer in project newrelic-java-agent by newrelic.

the class AbstractExceptionHandlerPointCut method doGetTracer.

@Override
public final Tracer doGetTracer(final Transaction transaction, ClassMethodSignature sig, Object errorHandler, Object[] args) {
    final Throwable throwable = getThrowable(sig, args);
    if (throwable == null) {
        return null;
    }
    return new DefaultTracer(transaction, sig, errorHandler, new ClassMethodMetricNameFormat(sig, errorHandler)) {

        @Override
        protected void doFinish(int opcode, Object returnValue) {
            // Should this be TransactionErrorPriority.TRACER?
            transaction.setThrowable(throwable, TransactionErrorPriority.API, false);
            super.doFinish(opcode, returnValue);
        }
    };
}

Example 37 with DefaultTracer

use of com.newrelic.agent.tracers.DefaultTracer in project newrelic-java-agent by newrelic.

the class InstrumentationImpl method oldCreateTracer.

// This code path is similar to the 3.16.1 and earlier tracer creation path. It is retained for use by legacy async
// instrumentation: Play1 and async servlet 3.0 instrumentation. The key difference from the "fast path" is that
// this path switches on the TransactionState during creation.
private ExitTracer oldCreateTracer(TransactionActivity txa, Object invocationTarget, int signatureId, String metricName, int flags) {
    // oldCreateTracer behavior below.
    if (txa == null) {
        AgentBridge.TokenAndRefCount tokenAndRefCount = AgentBridge.activeToken.get();
        if (tokenAndRefCount != null && tokenAndRefCount.token != null) {
            // Fast path for scala instrumentation (and potentially others in the future)
            Transaction tx = Transaction.getTransaction(false);
            if (tx == null) {
                if (tokenAndRefCount.token.getTransaction() instanceof Transaction) {
                    tx = (Transaction) tokenAndRefCount.token.getTransaction();
                } else {
                    return null;
                }
            }
            txa = TransactionActivity.create(tx, Integer.MAX_VALUE);
            flags = flags | TracerFlags.ASYNC;
            ClassMethodSignature sig = ClassMethodSignatures.get().get(signatureId);
            MetricNameFormat mnf = MetricNameFormats.getFormatter(invocationTarget, sig, metricName, flags);
            Tracer tracer;
            if (TracerFlags.isRoot(flags)) {
                // Dispatcher || Async
                tracer = new OtherRootTracer(txa, sig, invocationTarget, mnf, flags);
            } else {
                tracer = new DefaultTracer(txa, sig, invocationTarget, mnf, flags);
            }
            txa.tracerStarted(tracer);
            Tracer initiatingTracer = (Tracer) tokenAndRefCount.tracedMethod.getAndSet(tracer);
            tx.startFastAsyncWork(txa, initiatingTracer);
            return noticeTracer(signatureId, flags, tracer);
        } else if (TracerFlags.isAsync(flags)) {
            txa = TransactionActivity.create(null, Integer.MAX_VALUE);
            return startTracer(txa, invocationTarget, signatureId, metricName, flags);
        }
    }
    // Avoid creating tracers for NoOpTransaction, etc.
    com.newrelic.agent.Transaction transaction = com.newrelic.agent.Transaction.getTransaction(TracerFlags.isDispatcher(flags));
    if (transaction == null) {
        return null;
    }
    try {
        if (!TracerFlags.isDispatcher(flags) && !transaction.isStarted()) {
            // if we're not in a transaction and this isn't a dispatcher tracer, bail before we create objects
            return noticeTracer(signatureId, flags, null);
        }
        if (transaction.getTransactionActivity().isLeaf()) {
            return null;
        }
        ClassMethodSignature sig = ClassMethodSignatures.get().get(signatureId);
        return transaction.getTransactionState().getTracer(transaction, invocationTarget, sig, metricName, flags);
    } catch (Throwable t) {
        logger.log(Level.FINEST, t, "createTracer({0}, {1}, {2}, {3})", invocationTarget, signatureId, metricName, flags);
        return null;
    }
}

Example 38 with DefaultTracer

use of com.newrelic.agent.tracers.DefaultTracer in project newrelic-java-agent by newrelic.

the class InstrumentationImpl method createTracer.

/**
 * Optimized createTracer call for weaved and XML instrumentation. We do not know if either a TransactionActivity or
 * a Transaction is present on the thread. If present, we do not know if the Transaction has been started.
 */
@Override
public ExitTracer createTracer(Object invocationTarget, int signatureId, String metricName, int flags) {
    try {
        if (ServiceFactory.getServiceManager().isStopped()) {
            return null;
        }
        if (ServiceFactory.getServiceManager().getCircuitBreakerService().isTripped()) {
            return null;
        }
        TransactionActivity txa = TransactionActivity.get();
        if (txa != null) {
            if (txa.getRootTracer() != null && txa.getRootTracer().isAsync() && txa.getTransaction() == null) {
                txa = null;
            }
        }
        if (!Agent.canFastPath()) {
            // legacy async instrumentation is in use
            return oldCreateTracer(txa, invocationTarget, signatureId, metricName, flags);
        }
        if (txa == null) {
            AgentBridge.TokenAndRefCount tokenAndRefCount = AgentBridge.activeToken.get();
            if (tokenAndRefCount != null && tokenAndRefCount.token != null) {
                // Fast path for scala instrumentation (and potentially others in the future)
                Transaction tx = Transaction.getTransaction(false);
                if (tx == null) {
                    if (tokenAndRefCount.token.getTransaction() instanceof Transaction) {
                        tx = (Transaction) tokenAndRefCount.token.getTransaction();
                    } else {
                        return null;
                    }
                }
                txa = TransactionActivity.create(tx, Integer.MAX_VALUE);
                flags = flags | TracerFlags.ASYNC;
                ClassMethodSignature sig = ClassMethodSignatures.get().get(signatureId);
                MetricNameFormat mnf = MetricNameFormats.getFormatter(invocationTarget, sig, metricName, flags);
                Tracer tracer;
                if (TracerFlags.isRoot(flags)) {
                    // Dispatcher || Async
                    tracer = new OtherRootTracer(txa, sig, invocationTarget, mnf, flags);
                } else {
                    tracer = new DefaultTracer(txa, sig, invocationTarget, mnf, flags);
                }
                txa.tracerStarted(tracer);
                Tracer initiatingTracer = (Tracer) AgentBridge.activeToken.get().tracedMethod.getAndSet(tracer);
                tx.startFastAsyncWork(txa, initiatingTracer);
                return noticeTracer(signatureId, flags, tracer);
            } else if (TracerFlags.isDispatcher(flags)) {
                // Traditional first-time creation of a new transaction
                com.newrelic.agent.Transaction.getTransaction(true);
                txa = TransactionActivity.get();
            } else if (TracerFlags.isAsync(flags)) {
                // Create a transaction activity without a transaction
                txa = TransactionActivity.create(null, Integer.MAX_VALUE);
            }
            if (txa == null) {
                // or we are running on an Agent thread.
                return noticeTracer(signatureId, flags, null);
            }
            return noticeTracer(signatureId, flags, startTracer(txa, invocationTarget, signatureId, metricName, flags));
        }
        // traditional tracer creation code, we check it before creating any objects.
        if (!TracerFlags.isRoot(flags) && !txa.isStarted()) {
            return noticeTracer(signatureId, flags, null);
        }
        Tracer result = null;
        if (txa.checkTracerStart()) {
            try {
                ClassMethodSignature sig = ClassMethodSignatures.get().get(signatureId);
                // Metric naming. When we come here from an @Trace that doesn't specify a metric name, a
                // very common case, getFormatter() will return one of a couple of reusable instances of
                // MetricNameFormat, so we avoid proliferating small objects. But when we come here from
                // XML instrumentation, getFormatter() is forced to create a new MNF instance every time.
                // This proved to be messy to optimize, so unfortunately has been left as-is. 2015-05.
                MetricNameFormat mnf = MetricNameFormats.getFormatter(invocationTarget, sig, metricName, flags);
                if (TracerFlags.isDispatcher(flags) || (TracerFlags.isAsync(flags) && txa.getTransaction() != null && !txa.isStarted())) {
                    result = new OtherRootTracer(txa, sig, invocationTarget, mnf);
                } else {
                    result = new DefaultTracer(txa, sig, invocationTarget, mnf, flags);
                }
            } finally {
                txa.unlockTracerStart();
            }
            txa.tracerStarted(result);
        }
        return noticeTracer(signatureId, flags, result);
    } catch (Throwable t) {
        logger.log(Level.FINEST, t, "createTracer({0}, {1}, {2}, {3})", invocationTarget, signatureId, metricName, flags);
        return null;
    }
}

Example 39 with DefaultTracer

use of com.newrelic.agent.tracers.DefaultTracer in project newrelic-java-agent by newrelic.

the class XWork2ResultPC method doGetTracer.

@Override
public Tracer doGetTracer(Transaction transaction, ClassMethodSignature sig, Object result, Object[] args) {
    String name;
    try {
        Object action;
        if (args[0] instanceof ActionInvocation) {
            action = ((ActionInvocation) args[0]).getAction();
        } else {
            action = args[0].getClass().getMethod("getAction").invoke(args[0]);
        }
        name = action.getClass().getName();
    } catch (Throwable t) {
        name = "Unknown";
    }
    return new DefaultTracer(transaction, sig, result, new SimpleMetricNameFormat("StrutsResult/" + name));
}

Example 40 with DefaultTracer

use of com.newrelic.agent.tracers.DefaultTracer in project newrelic-java-agent by newrelic.

the class HandleInternalInvokerPointCut method doGetTracer.

@Override
public Tracer doGetTracer(final Transaction transaction, ClassMethodSignature sig, Object invoker, final Object[] args) {
    String methodName = null;
    Class<?> controller = null;
    StringBuilder tracerName = new StringBuilder("Spring/Java");
    // grab the information we need
    try {
        HandlerMethod methodInfo = (HandlerMethod) args[2];
        methodName = methodInfo._nr_getBridgedMethod().getName();
        controller = methodInfo._nr_getBean().getClass();
        // build the tracer name;
        tracerName.append(getControllerName(methodName, controller));
        setTransactionName(transaction, methodName, controller);
    } catch (Exception e) {
        // if it fails use the method name
        Agent.LOG.log(Level.FINE, "Unable to pull controller and method from spring framework.");
        Agent.LOG.log(Level.FINEST, "Exception grabbing spring controller.", e);
        tracerName.append(sig.getMethodName());
    }
    return new DefaultTracer(transaction, sig, invoker, new SimpleMetricNameFormat(tracerName.toString()));
}