TransactionActivity (newrelic-agent 8.0.0 API)

java.lang.Object
- com.newrelic.agent.TransactionActivity

```
public class TransactionActivity
extends java.lang.Object
```
This class tracks the state of a single asynchronous activity within a transaction. An instance of this class may be associated with e.g. a thread, the execution of a task on pool thread, or the execution of a "coroutine" on a thread.

This class is not threadsafe, but is typically referenced by two distinct threads during its lifetime. First, it holds state for its associated thread (or task, etc.) until its root tracer completes. It may then be queued (indirectly through its owning transaction) for harvest, during which it is referenced by the harvest thread. These two usages never overlap in time. Memory visibility is assured because the transaction will pass through a synchronized object (e.g. atomic or concurrent collection) that has the effect of inserting a full barrier between the async activity's last write and the harvest thread's first read.

Field Summary

Fields
Modifier and Type Field and Description

static int NOT_REPORTED

Fields
Modifier and Type	Field and Description
`static int`	`NOT_REPORTED`

Constructor Summary

Constructors
Constructor and Description

TransactionActivity()
The public constructor may be used only for test purposes.

Constructors
Constructor and Description
`TransactionActivity()` The public constructor may be used only for test purposes.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addTracer(Tracer tracer)`
`Tracer`	`addTracerToStack(Tracer tracer)` Copies a tracer to the call stack.
`boolean`	`canCreateTransactionSegment()` Return true if the tracer being created is allowed to create a new segment.
`boolean`	`checkTracerStart()` Optimized tracer start call.
`static void`	`clear()` Clear the TransactionActivity from the thread local that holds it.
`static TransactionActivity`	`create(Transaction transaction, int id)`
`static TransactionActivity`	`createWithoutHolder(Transaction transaction, int id, java.lang.String asyncContext)` Creates a TransactionActivity.
`void`	`finishFlyweightTracer(com.newrelic.agent.bridge.TracedMethod parent, long startInNanos, long finishInNanos, java.lang.String className, java.lang.String methodName, java.lang.String methodDesc, java.lang.String metricName, java.lang.String[] rollupMetricNames)`
`static TransactionActivity`	`get()`
`java.lang.String`	`getAsyncContext()`
`Tracer`	`getLastTracer()` Get the last tracer on the call stack, or null if the call stack is empty.
`Tracer`	`getRootTracer()`
`Segment`	`getSegment()`
`long`	`getThreadId()`
`long`	`getTotalCpuTime()` Returns the total cpu time in nanoseconds;
`java.util.List<Tracer>`	`getTracers()` Return the current state of the tracer stack for this activity.
`Transaction`	`getTransaction()`
`TransactionCache`	`getTransactionCache()` Get a cache to store objects for the life of the transaction.
`TransactionStats`	`getTransactionStats()`
`int`	`hashCode()`
`boolean`	`isFinished()`
`boolean`	`isIgnored()`
`boolean`	`isLeaf()` Return true if the tracer at the top of tracer stack is a flyweight tracer (leaf by default) or a leaf tracer.
`boolean`	`isNotInThreadLocal()`
`boolean`	`isStarted()`
`boolean`	`isTracerStartLocked()` Test the tracer start lock.
`void`	`lockTracerStart()` The tracer start lock is designed to prevent tracers from being created during the creation of another tracer.
`void`	`markAsResponseSender()`
`void`	`recordCpu()`
`static void`	`set(TransactionActivity txa)` Jam the argument into the thread local that holds it.
`void`	`setAsyncContext(java.lang.String asyncContext)` set the async context associated with this transaction activity.
`void`	`setSegment(Segment segment)`
`void`	`setToIgnore()`
`void`	`setTotalCpuTime(long totalCpuTimeInNanos)`
`void`	`startAsyncActivity(Transaction transaction, int activityId, Tracer parentTracer)`
`com.newrelic.agent.bridge.TracedMethod`	`startFlyweightTracer()`
`void`	`tracerFinished(Tracer tracer, int opcode)` Pop the finished tracer off the call stack.
`Tracer`	`tracerStarted(Tracer tracer)` Adds a tracer to the call stack.
`void`	`unlockTracerStart()` Release the tracer start lock.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NOT_REPORTED
```
public static final int NOT_REPORTED
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - TransactionActivity
```
public TransactionActivity()
```
    The public constructor may be used only for test purposes.
- Method Detail
  - clear
```
public static void clear()
```
    Clear the TransactionActivity from the thread local that holds it. This is a "dangerous" interface that is required for instrumentation in which the transaction+activity are multiplexed on a thread (e.g. "coroutine" or "continuation" mechanisms such as Javaflow or the async servlet interface).
  - set
```
public static void set(TransactionActivity txa)
```
    Jam the argument into the thread local that holds it. This is a "dangerous" interface that is required for instrumentation in which the transaction+activity are multiplexed on a thread (e.g. "coroutine" or "continuation" mechanisms such as Javaflow or the async servlet interface).
    
    Parameters:
    
    txa - the new value to make current
  - get
```
public static TransactionActivity get()
```
  - create
```
public static TransactionActivity create(Transaction transaction,
                                         int id)
```
  - createWithoutHolder
```
public static TransactionActivity createWithoutHolder(Transaction transaction,
                                                      int id,
                                                      java.lang.String asyncContext)
```
    Creates a TransactionActivity. Does not set the activity in the activityHolder; so it will not override whatever activity is currently in progress.
    
    Parameters:
    
    transaction - parent transaction
    
    id - ID of the activity
    
    asyncContext - name of async context; since external async spans multiple threads, this is typically the thread name that this is running on.
    
    Returns:
    
    activity
  - canCreateTransactionSegment
```
public boolean canCreateTransactionSegment()
```
    Return true if the tracer being created is allowed to create a new segment.
    
    Returns:
    
    true if the tracer being created is allowed to create a new segment.
  - markAsResponseSender
```
public void markAsResponseSender()
```
  - getThreadId
```
public long getThreadId()
```
  - getAsyncContext
```
public java.lang.String getAsyncContext()
```
    Returns:
    
    the async context associated with this transaction activity. This shows up on transaction traces.
  - setAsyncContext
```
public void setAsyncContext(java.lang.String asyncContext)
```
    set the async context associated with this transaction activity. This shows up on transaction traces.
  - getTransactionStats
```
public TransactionStats getTransactionStats()
```
  - getTracers
```
public java.util.List<Tracer> getTracers()
```
    Return the current state of the tracer stack for this activity.
    
    Returns:
    
    the current state of the tracer stack for this activity.
  - getTotalCpuTime
```
public long getTotalCpuTime()
```
    Returns the total cpu time in nanoseconds;
  - isNotInThreadLocal
```
public boolean isNotInThreadLocal()
```
  - setTotalCpuTime
```
public void setTotalCpuTime(long totalCpuTimeInNanos)
```
  - setToIgnore
```
public void setToIgnore()
```
  - isIgnored
```
public boolean isIgnored()
```
  - tracerStarted
```
public Tracer tracerStarted(Tracer tracer)
```
    Adds a tracer to the call stack.
    
    Parameters:
    
    tracer -
  - addTracerToStack
```
public Tracer addTracerToStack(Tracer tracer)
```
    Copies a tracer to the call stack.
    
    Parameters:
    
    tracer -
    
    Returns:
    
    The tracer if it was successfully added to the stack or null if it wasn't
  - tracerFinished
```
public void tracerFinished(Tracer tracer,
                           int opcode)
```
    Pop the finished tracer off the call stack.
  - isStarted
```
public boolean isStarted()
```
  - isFinished
```
public boolean isFinished()
```
  - isLeaf
```
public boolean isLeaf()
```
    Return true if the tracer at the top of tracer stack is a flyweight tracer (leaf by default) or a leaf tracer.
    
    Returns:
    
    true if the tracer at the top of tracer stack is a flyweight tracer (leaf by default) or a leaf tracer.
  - recordCpu
```
public void recordCpu()
```
  - addTracer
```
public void addTracer(Tracer tracer)
```
  - setSegment
```
public void setSegment(Segment segment)
```
  - getSegment
```
public Segment getSegment()
```
  - lockTracerStart
```
public void lockTracerStart()
```
    The tracer start lock is designed to prevent tracers from being created during the creation of another tracer. Acquire the lock. Note: fast path callers should use checkTracerStart() to reduce the number of method calls to this object.
  - unlockTracerStart
```
public void unlockTracerStart()
```
    Release the tracer start lock.
  - isTracerStartLocked
```
public boolean isTracerStartLocked()
```
    Test the tracer start lock.
    
    Returns:
    
    True if the lock is held. The "lock" is designed to prevent reentrancy by the thread already holding it, so of course it is implemented as a non-reentrant lock.
  - checkTracerStart
```
public boolean checkTracerStart()
```
    Optimized tracer start call. Checks several conditions and if all conditions hold then return true. Note: if a transaction is over its segment limit, we still create tracers, but don't start them. So we don't check the segment limit here.
    
    Returns:
    
    True if can create a tracer on this thread at this time else false. If the return value is true, the tracerStartLock is held and the caller is responsible for later calling unlockTracerStart().
  - getLastTracer
```
public Tracer getLastTracer()
```
    Get the last tracer on the call stack, or null if the call stack is empty.
  - startFlyweightTracer
```
public com.newrelic.agent.bridge.TracedMethod startFlyweightTracer()
```
  - finishFlyweightTracer
```
public void finishFlyweightTracer(com.newrelic.agent.bridge.TracedMethod parent,
                                  long startInNanos,
                                  long finishInNanos,
                                  java.lang.String className,
                                  java.lang.String methodName,
                                  java.lang.String methodDesc,
                                  java.lang.String metricName,
                                  java.lang.String[] rollupMetricNames)
```
  - startAsyncActivity
```
public void startAsyncActivity(Transaction transaction,
                               int activityId,
                               Tracer parentTracer)
```
  - getRootTracer
```
public Tracer getRootTracer()
```
  - getTransactionCache
```
public TransactionCache getTransactionCache()
```
    Get a cache to store objects for the life of the transaction.
  - getTransaction
```
public Transaction getTransaction()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object

Class TransactionActivity

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NOT_REPORTED

Constructor Detail

TransactionActivity

Method Detail

clear

set

get

create

createWithoutHolder

canCreateTransactionSegment

markAsResponseSender

getThreadId

getAsyncContext

setAsyncContext

getTransactionStats

getTracers

getTotalCpuTime

isNotInThreadLocal

setTotalCpuTime

setToIgnore

isIgnored

tracerStarted

addTracerToStack

tracerFinished

isStarted

isFinished

isLeaf

recordCpu

addTracer

setSegment

getSegment

lockTracerStart

unlockTracerStart

isTracerStartLocked

checkTracerStart

getLastTracer

startFlyweightTracer

finishFlyweightTracer

startAsyncActivity

getRootTracer

getTransactionCache

getTransaction

hashCode