Transaction (newrelic-agent 6.2.0 API)

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

Direct Known Subclasses:

DummyTransaction
```
public class Transaction
extends java.lang.Object
```
Represents a single transaction in the instrumented application. A transaction is a single top-level activity, such as servicing a single web request or a large-grained unit of background work.

Transactions are composed of one or more per-task work units, each of which is represented by a TransactionActivity object. The Transaction and the TransactionActivity are each referenced by a thread local variable.

Transactions are created by instrumented method invocations. Creation of the Transaction always creates a TransactionActivity. If an instrumented thread declares itself asynchronous, its Transaction is discarded and its TransactionActivity becomes associated with the top-level Transaction that originated it.

TransactionActivities are closed when the last tracer on their call stack is popped off. Transactions are closed when their last child TransactionActivity is finished and no further activities are pending.

This class is thread-safe.

Field Summary

Fields
Modifier and Type Field and Description

protected static com.newrelic.agent.bridge.WebResponse DEFAULT_RESPONSE

Fields
Modifier and Type	Field and Description
`protected static com.newrelic.agent.bridge.WebResponse`	`DEFAULT_RESPONSE`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Transaction()

Constructors
Modifier	Constructor and Description
`protected`	`Transaction()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`boolean`	`acceptDistributedTracePayload(com.newrelic.api.agent.DistributedTracePayload payload)`
`boolean`	`acceptDistributedTracePayload(java.lang.String payload)`
`void`	`activityFailedOrIgnored(TransactionActivity activity, int opcode)` The activity failed to complete normally, typically due to an internal error.
`void`	`activityFinished(TransactionActivity activity, Tracer tracer, int opcode)`
`void`	`addOutboundResponseHeaders()` Instruct the transaction to write the outbound response headers.
`void`	`addTotalCpuTimeForLegacy(long time)`
`void`	`checkExpire()` Check for any expired tokens or transaction activities.
`static void`	`clearTransaction()` Clear this thread's thread local reference to its transaction. Caution: in order to meet the functional expectations of legacy code, this method also clears the TransactionActivity from its thread-local variable on the current thread.
`boolean`	`conditionalSetPriorityTransactionName(TransactionNamingPolicy policy, java.lang.String name, java.lang.String category, com.newrelic.agent.bridge.TransactionNamePriority priority)`
`void`	`convertToWebTransaction()` Turns the current transaction from a background transaction into a web transaction.
`DistributedTracePayloadImpl`	`createDistributedTracePayload(java.lang.String spanId)`
`void`	`expireAllTokensForCurrentTransaction()`
`static boolean`	`expireToken(TokenImpl token)` This should only ever be called by the token.
`void`	`finishSegment(Segment segment, java.lang.Throwable throwable, Tracer parent, java.lang.String endThreadName)` Internal implementation of `TracedActivity.finish()` and `Segment.end()`.
`void`	`freezeStatus()`
`void`	`freezeTransactionName()` This has the side-effect of possibly ignoring the transaction as a result of applying server-side rules.
`java.util.Map<java.lang.String,java.lang.Object>`	`getAgentAttributes()` Custom parameters added by the Agent.
`AgentConfig`	`getAgentConfig()` Return the config for the current application name.
`java.lang.String`	`getApplicationName()`
`BrowserTransactionState`	`getBrowserTransactionState()`
`CrossProcessConfig`	`getCrossProcessConfig()`
`com.newrelic.agent.bridge.CrossProcessState`	`getCrossProcessState()`
`CrossProcessTransactionState`	`getCrossProcessTransactionState()`
`DatabaseStatementParser`	`getDatabaseStatementParser()`
`Dispatcher`	`getDispatcher()` Get the dispatcher for this transaction.
`java.util.Map<java.lang.String,java.lang.Object>`	`getErrorAttributes()` Custom attributes for an error added by this API call: `NewRelic.noticeError(String, Map)`
`long`	`getExternalTime()`
`java.util.Set<TransactionActivity>`	`getFinishedChildren()`
`java.lang.String`	`getGuid()` Return the GUID for this transaction.
`InboundHeaderState`	`getInboundHeaderState()` Get the inbound header state for this transaction, bringing it into existence if it does not already exist.
`long`	`getInitiatingThreadId()`
`com.newrelic.api.agent.Insights`	`getInsightsData()`
`java.util.Map<java.lang.String,java.lang.Object>`	`getInternalParameters()` Parameters used for internal agent processing.
`java.util.Map<java.lang.String,java.lang.Object>`	`getIntrinsicAttributes()` Custom parameters added by the Agent which cannot be turned off by the customer.
`long`	`getLargestTransportDurationInMillis()`
`java.lang.Object`	`getLock()` Get the lock on the object.
`com.newrelic.api.agent.MetricAggregator`	`getMetricAggregator()`
`TransactionNamingScheme`	`getNamingScheme()`
`java.lang.String`	`getNormalizedUri()` Deprecated.
`protected static Transaction`	`getOrCreateDummyTransaction()`
`java.lang.String`	`getOrCreateTraceId()`
`TransactionStats`	`getOverLimitTxStatsforTesting()`
`java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>>`	`getPrefixedAgentAttributes()` The HTTP request parameters.
`float`	`getPriority()`
`PriorityApplicationName`	`getPriorityApplicationName()`
`PriorityTransactionName`	`getPriorityTransactionName()`
`Tracer`	`getRootTracer()` Returns the root tracer - the first tracer in the transaction
`IRPMService`	`getRPMService()`
`long`	`getRunningDurationInNanos()`
`int`	`getRunningTransactionActivityCount()`
`SlowQueryListener`	`getSlowQueryListener(boolean createIfNotExists)`
`SpanProxy`	`getSpanProxy()`
`int`	`getStatus()`
`java.lang.String`	`getStatusMessage()`
`TransactionThrowable`	`getThrowable()`
`com.newrelic.agent.model.TimeoutCause`	`getTimeoutCause()`
`com.newrelic.agent.bridge.Token`	`getToken()` This should be the only place that increments the counter.
`java.util.List<Tracer>`	`getTracers()` Get the completed tracers for this transaction. In Agent versions through 3.10.x, this method could be called during a transaction in progress to get the current state of the tracer stack.
`static Transaction`	`getTransaction()` Returns this thread's reference to the transaction.
`static Transaction`	`getTransaction(boolean createIfNotExists)` Get this thread's reference to a transaction, creating it if this thread has no Transaction reference and creation is requested and allowable.
`TransactionActivity`	`getTransactionActivity()` Get this task's TransactionActivity
`TransactionCache`	`getTransactionCache()` Get a per-thread cache to store objects for the life of the transaction.
`TransactionCounts`	`getTransactionCounts()`
`TransactionState`	`getTransactionState()`
`TransactionTimer`	`getTransactionTimer()`
`TransactionTracerConfig`	`getTransactionTracerConfig()`
`long`	`getTransportDurationInMillis()`
`com.newrelic.agent.bridge.TransportType`	`getTransportType()`
`java.util.Map<java.lang.String,java.lang.Object>`	`getUserAttributes()` Custom parameters added by these API calls: `NewRelic.setAccountName(String)` `NewRelic.setProductName(String)` `NewRelic.setUserName(String)` `NewRelic.addCustomParameter(String, Number)` `NewRelic.addCustomParameter(String, String)`
`long`	`getWallClockStartTimeMs()` The start time of this transaction (wall clock time).
`com.newrelic.agent.bridge.WebResponse`	`getWebResponse()` Returns the web response associated with this transaction that tracks the response status code, message, etc.
`void`	`ignore()`
`void`	`ignoreApdex()`
`void`	`ignoreErrors()`
`void`	`ignoreSegmentIfUnfinished(Segment event)` Internal implementation of `TracedActivity.ignoreIfUnfinished()` and `Segment.ignore()`.
`boolean`	`isAutoAppNamingEnabled()`
`static boolean`	`isDummyRequest(com.newrelic.api.agent.Request request)`
`boolean`	`isErrorNotExpected()` This method should only be called at the END of a transaction, AFTER the application name is finalized.
`boolean`	`isErrorReportableAndNotIgnored()` This method should only be called at the END of a transaction, AFTER the application name is finalized.
`boolean`	`isFinished()` Return true if this transaction has been started and also finished.
`boolean`	`isIgnore()`
`boolean`	`isInProgress()` Return true if this transaction has been started and is not finished.
`boolean`	`isStarted()` Return true if the transaction has ever been started.
`boolean`	`isSynthetic()` Return true if this transaction is the result of a valid request from New Relic Synthetics.
`boolean`	`isTransactionNameSet()` Deprecated.
`boolean`	`isTransactionNamingEnabled()`
`boolean`	`isTransactionTraceEnabled()`
`boolean`	`isWebRequestSet()`
`boolean`	`isWebResponseSet()`
`boolean`	`isWebTransaction()` Returns true if in a web transaction.
`static boolean`	`linkTxOnThread(TokenImpl token)`
`boolean`	`markFirstByteOfResponse(long endTimeNs)`
`boolean`	`markLastByteOfResponse(long endTimeNs)`
`void`	`noticeTracerException(java.lang.Throwable throwable, java.lang.String spanId)` Capture the first tracer that had this unhandled exception.
`void`	`onRemoval()` No matter how the token is removed from the cache, check if we need to finish the transaction.
`void`	`provideHeaders(com.newrelic.api.agent.InboundHeaders headers)` Although the Transaction infrastructure was originally constructed to instrument transactions originated by web requests, the Java agent also supports transaction origination from JMS messages.
`void`	`provideRawHeaders(com.newrelic.api.agent.InboundHeaders headers)`
`void`	`recordFinalGCTime(TransactionStats stats)`
`void`	`refreshToken(TokenImpl token)` The token cache is expire after access, so the cache needs to be refreshed each time the token is used, which only matters in the link case.
`void`	`requestDestroyed()`
`void`	`requestInitialized(com.newrelic.api.agent.Request request, com.newrelic.api.agent.Response response)`
`boolean`	`sampled()`
`void`	`saveMessageParameters(java.util.Map<java.lang.String,java.lang.String> parameters)`
`void`	`setApplicationName(com.newrelic.api.agent.ApplicationNamePriority priority, java.lang.String appName)` Set the application name using a first setter (of a given priority) wins policy.
`void`	`setDispatcher(Dispatcher dispatcher)`
`void`	`setIgnore(boolean ignore)`
`void`	`setNormalizedUri(java.lang.String normalizedUri)` Deprecated.
`void`	`setPriorityIfNotNull(java.lang.Float priority)`
`boolean`	`setPriorityTransactionName(PriorityTransactionName ptn)` Forcibly set the priority transaction name, subverting the usual priority policy.
`void`	`setRequestAndResponse(com.newrelic.api.agent.Request request, com.newrelic.api.agent.Response response)`
`void`	`setThrowable(java.lang.Throwable throwable, TransactionErrorPriority priority, boolean expected)` Set the throwable with given priority.
`void`	`setTimeoutCause(com.newrelic.agent.model.TimeoutCause cause)`
`static void`	`setTransaction(Transaction tx)` Set this thread's thread local reference to the transaction. Caution: in order to meet the functional expectations of legacy code, this method also sets the thread-local variable holding the TransactionActivity to the TransactionActivity instance originally created with this Transaction instance.
`boolean`	`setTransactionName(com.newrelic.api.agent.TransactionNamePriority namePriority, boolean override, java.lang.String category, java.lang.String... parts)`
`boolean`	`setTransactionName(com.newrelic.agent.bridge.TransactionNamePriority namePriority, boolean override, java.lang.String category, java.lang.String... parts)`
`void`	`setTransactionState(TransactionState transactionState)`
`void`	`setTransportType(com.newrelic.agent.bridge.TransportType transportType)`
`void`	`setWebRequest(com.newrelic.api.agent.Request req)` Sets the request for the current transaction.
`void`	`setWebResponse(com.newrelic.api.agent.Response resp)` Sets the response for the current transaction.
`boolean`	`shouldGenerateTransactionSegment()`
`void`	`startFastAsyncWork(TransactionActivity txa, Tracer tracer)`
`Segment`	`startSegment(java.lang.String category, java.lang.String segmentName)` Internal implementation of `Transaction.createAndStartTracedActivity()` .
`void`	`startTransactionIfBeginning(Tracer tracer)`

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

- Field Detail
  - DEFAULT_RESPONSE
```
protected static final com.newrelic.agent.bridge.WebResponse DEFAULT_RESPONSE
```
- Constructor Detail
  - Transaction
```
protected Transaction()
```
- Method Detail
  - setTimeoutCause
```
public void setTimeoutCause(com.newrelic.agent.model.TimeoutCause cause)
```
  - getTimeoutCause
```
public com.newrelic.agent.model.TimeoutCause getTimeoutCause()
```
  - getTransportDurationInMillis
```
public long getTransportDurationInMillis()
```
  - createDistributedTracePayload
```
public DistributedTracePayloadImpl createDistributedTracePayload(java.lang.String spanId)
```
  - acceptDistributedTracePayload
```
public boolean acceptDistributedTracePayload(java.lang.String payload)
```
  - acceptDistributedTracePayload
```
public boolean acceptDistributedTracePayload(com.newrelic.api.agent.DistributedTracePayload payload)
```
  - getTransportType
```
public com.newrelic.agent.bridge.TransportType getTransportType()
```
  - getLargestTransportDurationInMillis
```
public long getLargestTransportDurationInMillis()
```
  - getSpanProxy
```
public SpanProxy getSpanProxy()
```
  - getOrCreateTraceId
```
public java.lang.String getOrCreateTraceId()
```
  - getMetricAggregator
```
public com.newrelic.api.agent.MetricAggregator getMetricAggregator()
```
  - getInitiatingThreadId
```
public long getInitiatingThreadId()
```
  - getLock
```
public java.lang.Object getLock()
```
    Get the lock on the object. This allows classes that interact heavily with the Transaction, e.g. CrossProcessTransactionStateImpl, to avoid the deadlock scenarios that would creep in if they defined their own locks. The consequence is possible making the Transaction's lock a hot lock. Please do not add this method to any interfaces. The fact that it's public is bad enough, but it must be for the sake of a badly-designed unit test.
    
    Returns:
    
    this object's lock
  - getGuid
```
public java.lang.String getGuid()
```
    Return the GUID for this transaction.
    
    Returns:
    
    the GUID for this transaction.
  - getAgentConfig
```
public AgentConfig getAgentConfig()
```
    Return the config for the current application name. Lazily but atomically initializes the default config if necessary.
  - getWallClockStartTimeMs
```
public long getWallClockStartTimeMs()
```
    The start time of this transaction (wall clock time). More precisely, the earlier of the time of the first request for this value and the actual start time of the transaction.
    Rationale: code in the Agent (or at least in the unit tests) sometimes queries this value after this object is created, but before the transaction is actually "started" (as we define "started"). If this happens, we snapshot the current time in order to ensure we give a consistent start time for this transaction.
  - getInternalParameters
```
public java.util.Map<java.lang.String,java.lang.Object> getInternalParameters()
```
    Parameters used for internal agent processing. Internal parameters are never sent to the server.
  - markFirstByteOfResponse
```
public boolean markFirstByteOfResponse(long endTimeNs)
```
  - markLastByteOfResponse
```
public boolean markLastByteOfResponse(long endTimeNs)
```
  - getPrefixedAgentAttributes
```
public java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>> getPrefixedAgentAttributes()
```
    The HTTP request parameters.
  - getUserAttributes
```
public java.util.Map<java.lang.String,java.lang.Object> getUserAttributes()
```
    Custom parameters added by these API calls: NewRelic.setAccountName(String) NewRelic.setProductName(String) NewRelic.setUserName(String) NewRelic.addCustomParameter(String, Number) NewRelic.addCustomParameter(String, String)
  - getAgentAttributes
```
public java.util.Map<java.lang.String,java.lang.Object> getAgentAttributes()
```
    Custom parameters added by the Agent. These can be turned off by the customer.
  - getIntrinsicAttributes
```
public java.util.Map<java.lang.String,java.lang.Object> getIntrinsicAttributes()
```
    Custom parameters added by the Agent which cannot be turned off by the customer. They are required for the site to function.
  - getErrorAttributes
```
public java.util.Map<java.lang.String,java.lang.Object> getErrorAttributes()
```
    Custom attributes for an error added by this API call: NewRelic.noticeError(String, Map)
  - getInsightsData
```
public com.newrelic.api.agent.Insights getInsightsData()
```
  - getTransactionTracerConfig
```
public TransactionTracerConfig getTransactionTracerConfig()
```
  - getCrossProcessConfig
```
public CrossProcessConfig getCrossProcessConfig()
```
  - setTransactionName
```
public boolean setTransactionName(com.newrelic.api.agent.TransactionNamePriority namePriority,
                                  boolean override,
                                  java.lang.String category,
                                  java.lang.String... parts)
```
  - setTransactionName
```
public boolean setTransactionName(com.newrelic.agent.bridge.TransactionNamePriority namePriority,
                                  boolean override,
                                  java.lang.String category,
                                  java.lang.String... parts)
```
  - isTransactionNameSet
```
@Deprecated
public boolean isTransactionNameSet()
```
    Deprecated.
    
    Return true if the name has been set. This method is inherently unreliable in a multithreaded environment and should not be used. There is no good substitute. Unfortunately, the method is exposed on the public API and cannot be removed.
    
    Returns:
    
    true if the name has been set at the moment the caller asks.
  - getPriorityTransactionName
```
public PriorityTransactionName getPriorityTransactionName()
```
  - freezeTransactionName
```
public void freezeTransactionName()
```
    This has the side-effect of possibly ignoring the transaction as a result of applying server-side rules.
  - conditionalSetPriorityTransactionName
```
public boolean conditionalSetPriorityTransactionName(TransactionNamingPolicy policy,
                                                     java.lang.String name,
                                                     java.lang.String category,
                                                     com.newrelic.agent.bridge.TransactionNamePriority priority)
```
  - setPriorityTransactionName
```
public boolean setPriorityTransactionName(PriorityTransactionName ptn)
```
    Forcibly set the priority transaction name, subverting the usual priority policy. Callers already holding the lock should call setPriorityTransactionNameLocked(com.newrelic.agent.transaction.PriorityTransactionName) directly.
    
    Parameters:
    
    ptn - the new name
    
    Returns:
    
    true if the name can be set
  - getSlowQueryListener
```
public SlowQueryListener getSlowQueryListener(boolean createIfNotExists)
```
  - getTransactionCache
```
public TransactionCache getTransactionCache()
```
    Get a per-thread cache to store objects for the life of the transaction.
  - isStarted
```
public boolean isStarted()
```
    Return true if the transaction has ever been started.
    
    Returns:
    
    true if the transaction has ever been started. This method will continue to return true when the transaction has finished. A transaction is started when a dispatcher is set on it.
  - isFinished
```
public boolean isFinished()
```
    Return true if this transaction has been started and also finished.
    
    Returns:
    
    true if this transaction has been started and also finished.
  - isInProgress
```
public boolean isInProgress()
```
    Return true if this transaction has been started and is not finished.
    
    Returns:
    
    true if this transaction has been started and is not finished.
  - getDispatcher
```
public Dispatcher getDispatcher()
```
    Get the dispatcher for this transaction.
    
    Returns:
    
    the dispatcher for this transaction, or null if the dispatcher has never been set.
  - getExternalTime
```
public long getExternalTime()
```
    Returns:
    
    the external time in milliseconds
  - getRootTracer
```
public Tracer getRootTracer()
```
    Returns the root tracer - the first tracer in the transaction
    
    Returns:
    
    the root tracer for this transaction. The return value may be null. Note: it is not possible to deduce anything about the state of the transaction from the state of the root tracer on the current thread. Do not use this method to determine transaction state.
  - getTracers
```
public java.util.List<Tracer> getTracers()
```
    Get the completed tracers for this transaction.
    
    In Agent versions through 3.10.x, this method could be called during a transaction in progress to get the current state of the tracer stack. The Agent async support post-3.10 introduced an ambiguity in the meaning of this method: did it return the current state of the tracers for the current async activity, or the entire set of tracers for the multiple activities that now compose a transaction? Most callers were interested in the latter, so this method now returns only the tracers associated with activities that have completed. In order to obtain the current state of the tracer stack for the currently-executing activity, use TransactionActivity.getTracers().
    
    Returns:
    
    the completed tracers for this transaction.
  - getOverLimitTxStatsforTesting
```
public TransactionStats getOverLimitTxStatsforTesting()
```
  - getTransactionActivity
```
public TransactionActivity getTransactionActivity()
```
    Get this task's TransactionActivity
    
    Returns:
    
    this asynchronous task's TransactionActivity
  - startTransactionIfBeginning
```
public void startTransactionIfBeginning(Tracer tracer)
```
  - setDispatcher
```
public void setDispatcher(Dispatcher dispatcher)
```
  - setTransportType
```
public void setTransportType(com.newrelic.agent.bridge.TransportType transportType)
```
  - getTransactionTimer
```
public TransactionTimer getTransactionTimer()
```
  - addTotalCpuTimeForLegacy
```
public void addTotalCpuTimeForLegacy(long time)
```
  - recordFinalGCTime
```
public void recordFinalGCTime(TransactionStats stats)
```
  - isTransactionTraceEnabled
```
public boolean isTransactionTraceEnabled()
```
  - isAutoAppNamingEnabled
```
public boolean isAutoAppNamingEnabled()
```
  - isTransactionNamingEnabled
```
public boolean isTransactionNamingEnabled()
```
  - getNamingScheme
```
public TransactionNamingScheme getNamingScheme()
```
  - isSynthetic
```
public boolean isSynthetic()
```
    Return true if this transaction is the result of a valid request from New Relic Synthetics.
    
    Returns:
    
    true if this transaction contains the Synthetics request header, the account ID can be verified as trusted, and the version is within the range of supported versions.
  - provideHeaders
```
public void provideHeaders(com.newrelic.api.agent.InboundHeaders headers)
```
    Although the Transaction infrastructure was originally constructed to instrument transactions originated by web requests, the Java agent also supports transaction origination from JMS messages. Both Cross application tracing (CAT) and cross-process tracking of synthetic transactions are fully supported for both JMS-originated transactions and across JMS-based external requests. This method allows instrumentation, e.g. the JMS instrumentation, to provide an InboundHeaders instance as the request headers for this transaction. In unusual cases, we may be within an HTTP transaction and synchronously execute JMS instrumentation that provides a second set of headers. In such cases, the HTTP headers "win".
    
    Parameters:
    
    headers - the proposed request headers
  - provideRawHeaders
```
public void provideRawHeaders(com.newrelic.api.agent.InboundHeaders headers)
```
    Parameters:
    
    headers - deobfuscated request headers.
  - getInboundHeaderState
```
public InboundHeaderState getInboundHeaderState()
```
    Get the inbound header state for this transaction, bringing it into existence if it does not already exist. If the transaction is not a web transaction and instrumentation (e.g. JMS instrumentation) has provided headers, we process the instrumentation-provided headers as our inbound request headers.
    
    Returns:
    
    an InboundHeaderState for this transaction. This method does not return null.
  - getRPMService
```
public IRPMService getRPMService()
```
  - clearTransaction
```
public static void clearTransaction()
```
    Clear this thread's thread local reference to its transaction.
    
    Caution: in order to meet the functional expectations of legacy code, this method also clears the TransactionActivity from its thread-local variable on the current thread.
  - setTransaction
```
public static void setTransaction(Transaction tx)
```
    Set this thread's thread local reference to the transaction.
    
    Caution: in order to meet the functional expectations of legacy code, this method also sets the thread-local variable holding the TransactionActivity to the TransactionActivity instance originally created with this Transaction instance. As a result, this method must not be used by code that changes the binding between Transaction and TransactionActivity, for example the implementation of the "start async" API method.
  - getTransaction
```
public static Transaction getTransaction()
```
    Returns this thread's reference to the transaction.
    
    Returns:
    
    this thread's reference to the transaction. The return value can be null, but only if this method is called from an Agent thread that is not already running within a Transaction. When called from a non-Agent thread, the result is not null.
  - refreshToken
```
public void refreshToken(TokenImpl token)
```
    The token cache is expire after access, so the cache needs to be refreshed each time the token is used, which only matters in the link case.
  - linkTxOnThread
```
public static boolean linkTxOnThread(TokenImpl token)
```
  - startFastAsyncWork
```
public void startFastAsyncWork(TransactionActivity txa,
                               Tracer tracer)
```
  - getTransaction
```
public static Transaction getTransaction(boolean createIfNotExists)
```
    Get this thread's reference to a transaction, creating it if this thread has no Transaction reference and creation is requested and allowable.
    
    Parameters:
    
    createIfNotExists - true to request creation of the object
    
    Returns:
    
    the transaction. Return null if createIfNotExists is false and the transaction has not previously been created, or if the current thread is an Agent thread.
  - getOrCreateDummyTransaction
```
protected static Transaction getOrCreateDummyTransaction()
```
  - setNormalizedUri
```
@Deprecated
public void setNormalizedUri(java.lang.String normalizedUri)
```
    Deprecated.
    
    Use NewRelic#setTransactionName(String, String)
  - getNormalizedUri
```
@Deprecated
public java.lang.String getNormalizedUri()
```
    Deprecated.
    
    Use getPriorityTransactionName()
    
    Returns:
    
    the normalized URI for this transaction, or null if not set
  - getThrowable
```
public TransactionThrowable getThrowable()
```
  - isErrorReportableAndNotIgnored
```
public boolean isErrorReportableAndNotIgnored()
```
    This method should only be called at the END of a transaction, AFTER the application name is finalized.
  - isErrorNotExpected
```
public boolean isErrorNotExpected()
```
    This method should only be called at the END of a transaction, AFTER the application name is finalized.
  - getStatus
```
public int getStatus()
```
  - getStatusMessage
```
public java.lang.String getStatusMessage()
```
  - freezeStatus
```
public void freezeStatus()
```
  - setThrowable
```
public void setThrowable(java.lang.Throwable throwable,
                         TransactionErrorPriority priority,
                         boolean expected)
```
    Set the throwable with given priority. Calls with null throwable are ignored. Unless on initial TransactionActivity, calls with non-API priority are ignored. This means if an async TransactionActivity throws an exception, you must report via the API as the tracer will ignore it. This behavior is intentional in order to properly support the majority of async cases where a common pattern is to spin off work to another thread, catch any exceptions thrown from that thread and then handle them in the initial thread. There are cases where this pattern may fall apart but we should treat those as special cases which can use the API in order to report the "correct" error.
    
    Parameters:
    
    throwable - the throwable that should be reported
    
    priority - the priority of the throwable. If set to TransactionErrorPriority.TRACER and not reported
    
    expected -
  - noticeTracerException
```
public void noticeTracerException(java.lang.Throwable throwable,
                                  java.lang.String spanId)
```
    Capture the first tracer that had this unhandled exception.
    
    Parameters:
    
    throwable - The unhandled exception from the tracer
    
    spanId - The Tracer GUID
  - isIgnore
```
public boolean isIgnore()
```
  - ignore
```
public void ignore()
```
  - setIgnore
```
public void setIgnore(boolean ignore)
```
  - ignoreApdex
```
public void ignoreApdex()
```
  - ignoreErrors
```
public void ignoreErrors()
```
  - getTransactionCounts
```
public TransactionCounts getTransactionCounts()
```
  - shouldGenerateTransactionSegment
```
public boolean shouldGenerateTransactionSegment()
```
  - getDatabaseStatementParser
```
public DatabaseStatementParser getDatabaseStatementParser()
```
  - getBrowserTransactionState
```
public BrowserTransactionState getBrowserTransactionState()
```
  - getCrossProcessState
```
public com.newrelic.agent.bridge.CrossProcessState getCrossProcessState()
```
  - getCrossProcessTransactionState
```
public CrossProcessTransactionState getCrossProcessTransactionState()
```
  - getTransactionState
```
public TransactionState getTransactionState()
```
  - setTransactionState
```
public void setTransactionState(TransactionState transactionState)
```
  - addOutboundResponseHeaders
```
public void addOutboundResponseHeaders()
```
    Instruct the transaction to write the outbound response headers. This must be called before response headers are sent and the response is committed. Successive calls will have no effect (first wins). This must be called after setWebRequest(Request)} and setWebResponse(Response).
  - getWebResponse
```
public com.newrelic.agent.bridge.WebResponse getWebResponse()
```
    Returns the web response associated with this transaction that tracks the response status code, message, etc. This method will always return an object so there's no need for a null check.
  - isWebTransaction
```
public boolean isWebTransaction()
```
    Returns true if in a web transaction.
  - convertToWebTransaction
```
public void convertToWebTransaction()
```
    Turns the current transaction from a background transaction into a web transaction.
  - setRequestAndResponse
```
public void setRequestAndResponse(com.newrelic.api.agent.Request request,
                                  com.newrelic.api.agent.Response response)
```
  - isWebRequestSet
```
public boolean isWebRequestSet()
```
  - isWebResponseSet
```
public boolean isWebResponseSet()
```
  - setWebRequest
```
public void setWebRequest(com.newrelic.api.agent.Request req)
```
    Sets the request for the current transaction. Setting the request will convert the current transaction into a web transaction. Successive calls will have no effect (first wins).
    
    Parameters:
    
    req - The current transaction's request.
  - setWebResponse
```
public void setWebResponse(com.newrelic.api.agent.Response resp)
```
    Sets the response for the current transaction. Setting the response will convert the current transaction into a web transaction. Successive calls will have no effect (first wins).
    
    Parameters:
    
    resp - The current transaction's response.
  - requestInitialized
```
public void requestInitialized(com.newrelic.api.agent.Request request,
                               com.newrelic.api.agent.Response response)
```
  - requestDestroyed
```
public void requestDestroyed()
```
  - isDummyRequest
```
public static boolean isDummyRequest(com.newrelic.api.agent.Request request)
```
  - getApplicationName
```
public java.lang.String getApplicationName()
```
  - getPriorityApplicationName
```
public PriorityApplicationName getPriorityApplicationName()
```
  - setApplicationName
```
public void setApplicationName(com.newrelic.api.agent.ApplicationNamePriority priority,
                               java.lang.String appName)
```
    Set the application name using a first setter (of a given priority) wins policy. This is the legacy behavior for the public API.
    
    Parameters:
    
    priority - the priority
    
    appName - the name to set if the argument priority is higher than that existing priority.
  - getRunningDurationInNanos
```
public long getRunningDurationInNanos()
```
  - saveMessageParameters
```
public void saveMessageParameters(java.util.Map<java.lang.String,java.lang.String> parameters)
```
  - getToken
```
public com.newrelic.agent.bridge.Token getToken()
```
    This should be the only place that increments the counter.
  - expireToken
```
public static boolean expireToken(TokenImpl token)
```
    This should only ever be called by the token. Otherwise the flag on the token will not get set correctly
    
    Parameters:
    
    token - The token to expire.
    
    Returns:
    
    True if the token was expired.
  - expireAllTokensForCurrentTransaction
```
public void expireAllTokensForCurrentTransaction()
```
  - onRemoval
```
public void onRemoval()
```
    No matter how the token is removed from the cache, check if we need to finish the transaction. This should be the ONLY place that decrements the counter (via checkFinishTransactionFromToken())
  - checkExpire
```
public void checkExpire()
```
    Check for any expired tokens or transaction activities.
  - startSegment
```
public Segment startSegment(java.lang.String category,
                            java.lang.String segmentName)
```
    Internal implementation of Transaction.createAndStartTracedActivity() . This has to happen inside the transaction class because it requires updates to an async map (runningChildren)
  - ignoreSegmentIfUnfinished
```
public void ignoreSegmentIfUnfinished(Segment event)
```
    Internal implementation of TracedActivity.ignoreIfUnfinished() and Segment.ignore().
    
    Parameters:
    
    event - The unfinished activity to ignore.
  - finishSegment
```
public void finishSegment(Segment segment,
                          java.lang.Throwable throwable,
                          Tracer parent,
                          java.lang.String endThreadName)
```
    Internal implementation of TracedActivity.finish() and Segment.end(). This has to happen inside the transaction class because it requires updates to finishedChildren
    
    Parameters:
    
    segment - The Segment to finish.
    
    throwable - A throwable to finish the activity tracer with. May be null.
  - getRunningTransactionActivityCount
```
public int getRunningTransactionActivityCount()
```
  - activityFailedOrIgnored
```
public void activityFailedOrIgnored(TransactionActivity activity,
                                    int opcode)
```
    The activity failed to complete normally, typically due to an internal error. Do not use this method to handle errors detected in the instrumented application. All information associated with the activity is lost.
    
    Parameters:
    
    activity - the activity that failed
    
    opcode -
  - activityFinished
```
public void activityFinished(TransactionActivity activity,
                             Tracer tracer,
                             int opcode)
```
  - getFinishedChildren
```
public java.util.Set<TransactionActivity> getFinishedChildren()
```
  - getPriority
```
public float getPriority()
```
  - setPriorityIfNotNull
```
public void setPriorityIfNotNull(java.lang.Float priority)
```
  - sampled
```
public boolean sampled()
```

Class Transaction

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_RESPONSE

Constructor Detail

Transaction

Method Detail

setTimeoutCause

getTimeoutCause

getTransportDurationInMillis

createDistributedTracePayload

acceptDistributedTracePayload

acceptDistributedTracePayload

getTransportType

getLargestTransportDurationInMillis

getSpanProxy

getOrCreateTraceId

getMetricAggregator

getInitiatingThreadId

getLock

getGuid

getAgentConfig

getWallClockStartTimeMs

getInternalParameters

markFirstByteOfResponse

markLastByteOfResponse

getPrefixedAgentAttributes

getUserAttributes

getAgentAttributes

getIntrinsicAttributes

getErrorAttributes

getInsightsData

getTransactionTracerConfig

getCrossProcessConfig

setTransactionName

setTransactionName

isTransactionNameSet

getPriorityTransactionName

freezeTransactionName

conditionalSetPriorityTransactionName

setPriorityTransactionName

getSlowQueryListener

getTransactionCache

isStarted

isFinished

isInProgress

getDispatcher

getExternalTime

getRootTracer

getTracers

getOverLimitTxStatsforTesting

getTransactionActivity

startTransactionIfBeginning

setDispatcher

setTransportType

getTransactionTimer

addTotalCpuTimeForLegacy

recordFinalGCTime

isTransactionTraceEnabled

isAutoAppNamingEnabled

isTransactionNamingEnabled

getNamingScheme

isSynthetic

provideHeaders

provideRawHeaders

getInboundHeaderState

getRPMService

clearTransaction

setTransaction

getTransaction

refreshToken

linkTxOnThread

startFastAsyncWork

getTransaction

getOrCreateDummyTransaction

setNormalizedUri

getNormalizedUri