piggyback log events on transactions to pool their priorities

v3/examples/server/main.go

@@ -252,7 +252,6 @@ func main() {
 		newrelic.ConfigAppName("Example App"),
 		newrelic.ConfigFromEnvironment(),
 		newrelic.ConfigDebugLogger(os.Stdout),
-		newrelic.ConfigDistributedTracerEnabled(true),
 		newrelic.ConfigAppLogForwardingEnabled(true),
 	)
 	if err != nil {
@@ -278,28 +277,31 @@ func main() {
 	http.HandleFunc(newrelic.WrapHandleFunc(app, "/async", async))
 	http.HandleFunc(newrelic.WrapHandleFunc(app, "/message", message))
 	http.HandleFunc("/log", func(w http.ResponseWriter, req *http.Request) {
-		// Transactions started without an http.Request are classified as
-		// background transactions.
-		txn := app.StartTransaction("Log")
-		defer txn.End()
-
-		ctx := newrelic.NewContext(context.Background(), txn)
-
 		// Versions of go prior to 1.17 do not have a built in function for Unix Milli time.
 		// For go versions 1.17+ use time.Now().UnixMilli() to generate timestamps
 		timestamp := time.Now().UnixNano() / int64(time.Millisecond)
-
-		data := newrelic.LogData{
+		app.RecordLog(newrelic.LogData{
 			Timestamp: timestamp,
 			Message:   "Log Message",
 			Severity:  "info",
-			Context:   ctx,
-		}
+		})
 
-		app.RecordLog(data)
+		io.WriteString(w, "A log message was recorded")
+	})
 
-		io.WriteString(w, "Log")
-		time.Sleep(150 * time.Millisecond)
+	http.HandleFunc("/transaction_log", func(w http.ResponseWriter, req *http.Request) {
+		txn := app.StartTransaction("Log Transaction")
+		defer txn.End()
+		ctx := newrelic.NewContext(context.Background(), txn)
+
+		app.RecordLog(newrelic.LogData{
+			Timestamp: time.Now().UnixNano() / int64(time.Millisecond),
+			Message:   "Transaction Log Message",
+			Severity:  "info",
+			Context:   ctx,
+		})
+
+		io.WriteString(w, "A log message was recorded as part of a transaction")
 	})
 
 	http.HandleFunc("/background", func(w http.ResponseWriter, req *http.Request) {

v3/newrelic/internal_app.go

@@ -596,8 +596,22 @@ func (app *app) RecordLog(log *LogData) error {
 		return err
 	}
 
-	run, _ := app.getState()
-	app.Consume(run.Reply.RunID, &event)
+	var txn *Transaction
+	if log.Context != nil {
+		txn = FromContext(log.Context)
+	}
+
+	// Whenever a log is part of a transaction, store it on the transaction
+	// to ensure it gets correctly prioritized.
+	if txn != nil {
+		metadata := txn.GetTraceMetadata()
+		event.spanID = metadata.SpanID
+		event.traceID = metadata.SpanID
+		txn.thread.StoreLog(&event)
+	} else {
+		run, _ := app.getState()
+		app.Consume(run.Reply.RunID, &event)
+	}
 	return nil
 }
 

v3/newrelic/internal_txn.go

@@ -226,6 +226,19 @@ func (thd *thread) SetWebResponse(w http.ResponseWriter) http.ResponseWriter {
 	})
 }
 
+func (thd *thread) StoreLog(log *logEvent) {
+	txn := thd.txn
+	txn.Lock()
+	defer txn.Unlock()
+
+	// Copy log data into the slice so that the stack frame can return without needing to allocate heap memory
+	if txn.logs == nil {
+		txn.logs = []logEvent{*log}
+	} else {
+		txn.logs = append(txn.logs, *log)
+	}
+}
+
 func (txn *txn) freezeName() {
 	if txn.ignore || ("" != txn.FinalName) {
 		return
@@ -262,6 +275,13 @@ func (txn *txn) MergeIntoHarvest(h *harvest) {
 	createTxnMetrics(&txn.txnData, h.Metrics)
 	mergeBreakdownMetrics(&txn.txnData, h.Metrics)
 
+	// Dump log events into harvest
+	// Note: this will create a surge of log events that could affect sampling.
+	for _, logEvent := range txn.logs {
+		logEvent.priority = priority
+		h.LogEvents.Add(&logEvent)
+	}
+
 	if txn.Config.TransactionEvents.Enabled {
 		// Allocate a new TxnEvent to prevent a reference to the large transaction.
 		alloc := new(txnEvent)

v3/newrelic/log_event.go

@@ -108,24 +108,10 @@ func (data *LogData) toLogEvent() (logEvent, error) {
 	data.Message = strings.TrimSpace(data.Message)
 	data.Severity = strings.TrimSpace(data.Severity)
 
-	var spanID, traceID string
-	var priority priority
-
-	if data.Context != nil {
-		txn := FromContext(data.Context)
-		priority = txn.thread.BetterCAT.Priority
-		traceMetadata := txn.GetTraceMetadata()
-		spanID = traceMetadata.SpanID
-		traceID = traceMetadata.TraceID
-	}
-
 	event := logEvent{
 		message:   data.Message,
 		severity:  data.Severity,
-		spanID:    spanID,
-		traceID:   traceID,
 		timestamp: data.Timestamp,
-		priority:  priority,
 	}
 
 	return event, nil

v3/newrelic/tracing.go

@@ -79,6 +79,7 @@ type txnData struct {
 	rootSpanID              string
 	rootSpanErrData         *errorData
 	SpanEvents              []*spanEvent
+	logs                    []logEvent
 
 	customSegments    map[string]*metricData
 	datastoreSegments map[datastoreMetricKey]*metricData