All Implemented Interfaces:

com.datadog.trace.bootstrap.instrumentation.api.AgentTrace , com.datadog.trace.core.PendingTraceBuffer.Element
```
public class PendingTrace
 implements AgentTrace, PendingTraceBuffer.Element
                    
```
This class implements the following data flow rules when a Span is finished:
- Immediate Write
  - pending ref count == 0 && trace not already written
  - not root span && size exceeds partial flush
- Delayed Write
  - is root span && pending ref count > 0
  - not root span && pending ref count > 0 && trace already written
Delayed write is handled by PendingTraceBuffer.
When the long-running traces feature is enabled, periodic writes are triggered by the PendingTraceBuffer in addition to the other write conditions. Running spans are also written in that case.

Field Summary

Fields
Modifier and Type	Field	Description
`private final TimeSource`	`timeSource`
`private volatile int`	`pendingReferenceCount`
`private volatile DDSpan`	`rootSpan`
`private volatile long`	`endToEndStartTime`

Method Summary

Modifier and Type	Method	Description
`TimeSource`	`getTimeSource()`
`int`	`getPendingReferenceCount()`
`DDSpan`	`getRootSpan()`
`long`	`getEndToEndStartTime()`
`long`	`getCurrentTimeNano()`	Current timestamp in nanoseconds; 'touches' the trace by updating lastReferenced.
`void`	`touch()`
`boolean`	`lastReferencedNanosAgo(long nanos)`
`Integer`	`evaluateSamplingPriority()`
`boolean`	`compareAndSetLongRunningState(int expected, int newState)`
`long`	`oldestFinishedTime()`
`void`	`registerContinuation(AgentScope.Continuation continuation)`	When using continuations, it's possible one may be used after all existing spans are otherwisecompleted, so we need to wait till continuations are de-referenced before reporting.
`void`	`cancelContinuation(AgentScope.Continuation continuation)`
`void`	`write()`	Important to note: may be called multiple times.
`int`	`enqueueSpansToWrite(List<DDSpan> trace, boolean writeRunningSpans)`
`int`	`size()`
`void`	`beginEndToEnd()`
`long`	`getLastWriteTime()`
`long`	`getRunningTraceStartTime()`
`void`	`setLastWriteTime(long now)`
`boolean`	`isRootSpanWritten()`
`boolean`	`setEnqueued(boolean enqueued)`	Set or clear if the `{@code Element}` is enqueued.
`boolean`	`writeOnBufferFull()`	Called when the pendingTraceBuffer is full and a pendingTrace is offered.
`static long`	`getDurationNano(CoreSpan<out Object> span)`	Calculates the duration of a span in nanoseconds for the transport layerAs the internal duration of a running span is 0, the duration is set to the differencebetween the span's start time and the time of the write trigger.
`void`	`setSamplingPriorityIfNecessary()`
`boolean`	`sample(DDSpan spanToSample)`

Methods inherited from class com.datadog.trace.bootstrap.instrumentation.api.AgentTrace
cancelContinuation, registerContinuation
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getTimeSource
```
 TimeSource getTimeSource()
```
  - getPendingReferenceCount
```
 int getPendingReferenceCount()
```
  - getRootSpan
```
 DDSpan getRootSpan()
```
  - getEndToEndStartTime
```
 long getEndToEndStartTime()
```
  - getCurrentTimeNano
```
 long getCurrentTimeNano()
```
    Current timestamp in nanoseconds; 'touches' the trace by updating lastReferenced.
    Note: This method uses trace start time as a reference and it gets time with nanosecondprecision after that. This means time measured within same Trace in different Spans isrelatively correct with nanosecond precision.
  - touch
```
 void touch()
```
  - lastReferencedNanosAgo
```
 boolean lastReferencedNanosAgo(long nanos)
```
  - evaluateSamplingPriority
```
 Integer evaluateSamplingPriority()
```
  - compareAndSetLongRunningState
```
 boolean compareAndSetLongRunningState(int expected, int newState)
```
  - oldestFinishedTime
```
 long oldestFinishedTime()
```
  - registerContinuation
```
 void registerContinuation(AgentScope.Continuation continuation)
```
    When using continuations, it's possible one may be used after all existing spans are otherwisecompleted, so we need to wait till continuations are de-referenced before reporting.
  - cancelContinuation
```
 void cancelContinuation(AgentScope.Continuation continuation)
```
  - write
```
 void write()
```
    Important to note: may be called multiple times.
  - enqueueSpansToWrite
```
 int enqueueSpansToWrite(List<DDSpan> trace, boolean writeRunningSpans)
```
  - size
```
 int size()
```
  - beginEndToEnd
```
 void beginEndToEnd()
```
  - getLastWriteTime
```
 long getLastWriteTime()
```
  - getRunningTraceStartTime
```
 long getRunningTraceStartTime()
```
  - setLastWriteTime
```
 void setLastWriteTime(long now)
```
  - isRootSpanWritten
```
 boolean isRootSpanWritten()
```
  - setEnqueued
```
 boolean setEnqueued(boolean enqueued)
```
    Set or clear if the {@code Element} is enqueued. Needs to be atomic.
    
    Parameters:
    
    enqueued - true if the enqueued state should be set or false if it should be cleared
  - writeOnBufferFull
```
 boolean writeOnBufferFull()
```
    Called when the pendingTraceBuffer is full and a pendingTrace is offered.
    If the pendingTrace is not sent to the LongRunningTracesTracker, it will be immediatelywritten. Otherwise, the pendingTrace won't be tracked and no write is triggered.
  - getDurationNano
```
 static long getDurationNano(CoreSpan<out Object> span)
```
    Calculates the duration of a span in nanoseconds for the transport layer
    As the internal duration of a running span is 0, the duration is set to the differencebetween the span's start time and the time of the write trigger.
  - setSamplingPriorityIfNecessary
```
 void setSamplingPriorityIfNecessary()
```
  - sample
```
 boolean sample(DDSpan spanToSample)
```

Class PendingTrace

Field Summary

Method Summary

Methods inherited from class com.datadog.trace.bootstrap.instrumentation.api.AgentTrace

Methods inherited from class java.lang.Object

Method Detail

getTimeSource

getPendingReferenceCount

getRootSpan

getEndToEndStartTime

getCurrentTimeNano

touch

lastReferencedNanosAgo

evaluateSamplingPriority

compareAndSetLongRunningState

oldestFinishedTime

registerContinuation

cancelContinuation

write

enqueueSpansToWrite

size

beginEndToEnd

getLastWriteTime

getRunningTraceStartTime

setLastWriteTime

isRootSpanWritten

setEnqueued

writeOnBufferFull

getDurationNano

setSamplingPriorityIfNecessary

sample