No way to check if a transaction has ended

[frknikiz]

Summary

This feature request proposes adding a new method to the New Relic Go agent's Transaction object that allows developers to check if a transaction has been ended.

Desired Behaviour

Currently, there is no way to directly determine if a transaction has been ended, especially when the End() call is made in a separate goroutine. This can lead to uncertainty and potential issues in tracking the status of transactions.

The desired behavior is to have a method, such as IsEnded(), that returns a boolean value indicating whether the End() method has been called on the transaction. This would allow developers to reliably check the transaction's status and handle it accordingly.

For example:

txn:= newrelic.FromContext(r.Context())

//... some code...

go func() {
  //... some code...
  txn.End()
}()

//... some code...

if txn.IsEnded() {
  // Transaction has ended
} else {
  // Transaction is still active
}

Possible Solution

Examining the current Transaction struct reveals a finished boolean field within the nested txn struct, which appears to track the transaction's end state.

type Transaction struct {
    Private any
    thread  *thread
}

type thread struct {
    *txn
    // ... other fields
}

type txn struct {
    // ... other fields
    finished           bool
    // ... other fields
}

Leveraging this existing field, the IsEnded() method could be implemented as follows:

func (t *Transaction) IsEnded() bool {
  if t == nil || t.thread == nil || t.thread.txn == nil {
    return true
  }
  return t.thread.txn.finished
}

This method first handles potential nil cases to prevent panics and then directly accesses the finished field to provide the desired functionality.

Additional context

This feature is important for applications that heavily rely on asynchronous processing and goroutines. In such scenarios, it can be difficult to keep track of the status of transactions, and the proposed method would provide a clear and reliable way to do so. This would help in debugging, ensuring proper transaction completion, and managing resources effectively.