model/modeldecoder: {span,transaction}.outcome

model/modeldecoder/field/rum_v3_mapping.go

@@ -77,6 +77,7 @@ var rumV3Mapping = map[string]string{
 	"module":                      "mo",
 	"name":                        "n",
 	"navigationTiming":            "nt",
+	"outcome":                     "o",
 	"page":                        "p",
 	"param_message":               "pmg",
 	"parent_id":                   "pid",

model/modeldecoder/span.go

@@ -93,6 +93,7 @@ func decodeSpan(input Input, schema *jsonschema.Schema) (_ *model.Span, parentIn
 	decodeString(raw, fieldName("parent_id"), &event.ParentID)
 	decodeString(raw, fieldName("trace_id"), &event.TraceID)
 	decodeString(raw, fieldName("transaction_id"), &event.TransactionID)
+	decodeString(raw, fieldName("outcome"), &event.Outcome)
 
 	ctx := decoder.MapStr(raw, fieldName("context"))
 	if ctx != nil {

model/modeldecoder/span_test.go

@@ -45,6 +45,7 @@ func TestDecodeSpan(t *testing.T) {
 	instance, statement, dbType, user, link, rowsAffected := "db01", "select *", "sql", "joe", "other.db.com", 34
 	address, port := "localhost", 8080
 	destServiceType, destServiceName, destServiceResource := "db", "elasticsearch", "elasticsearch"
+	outcome := "success"
 	context := map[string]interface{}{
 		"a":    "b",
 		"tags": map[string]interface{}{"a": "tag", "tag_key": 17},
@@ -191,6 +192,7 @@ func TestDecodeSpan(t *testing.T) {
 				"name": name, "type": "messaging", "subtype": subtype, "action": action, "start": start,
 				"duration": duration, "context": context, "timestamp": timestampEpoch, "stacktrace": stacktrace,
 				"id": id, "parent_id": parentID, "trace_id": traceID, "transaction_id": transactionID,
+				"outcome": outcome,
 			},
 			e: &m.Span{
 				Metadata:  metadata,
@@ -201,6 +203,7 @@ func TestDecodeSpan(t *testing.T) {
 				Start:     &start,
 				Duration:  duration,
 				Timestamp: spanTime,
+				Outcome:   outcome,
 				Stacktrace: m.Stacktrace{
 					&m.StacktraceFrame{Filename: tests.StringPtr("file")},
 				},
@@ -296,6 +299,10 @@ func TestDecodeSpanInvalid(t *testing.T) {
 			input: map[string]interface{}{"duration": -1.0},
 			err:   "duration.*must be >= 0 but found -1",
 		},
+		"invalid outcome": {
+			input: map[string]interface{}{"outcome": `¯\_(ツ)_/¯`},
+			err:   `outcome.*must be one of <nil>, "success", "failure", "unknown"`,
+		},
 	} {
 		t.Run(name, func(t *testing.T) {
 			input := make(map[string]interface{})

model/modeldecoder/transaction.go

@@ -163,6 +163,7 @@ func decodeTransaction(input Input, schema *jsonschema.Schema) (*model.Transacti
 	decodeString(raw, fieldName("type"), &e.Type)
 	decodeString(raw, fieldName("name"), &e.Name)
 	decodeString(raw, fieldName("result"), &e.Result)
+	decodeString(raw, fieldName("outcome"), &e.Outcome)
 	decodeFloat64(raw, fieldName("duration"), &e.Duration)
 	if e.Timestamp.IsZero() {
 		e.Timestamp = input.RequestTime

model/modeldecoder/transaction_test.go

@@ -33,10 +33,11 @@ import (
 )
 
 var (
-	trID     = "123"
-	trType   = "type"
-	trName   = "foo()"
-	trResult = "555"
+	trID      = "123"
+	trType    = "type"
+	trName    = "foo()"
+	trResult  = "555"
+	trOutcome = "success"
 
 	trDuration = 6.0
 
@@ -68,6 +69,7 @@ var fullTransactionInput = map[string]interface{}{
 	"duration":   trDuration,
 	"timestamp":  timestampEpoch,
 	"result":     trResult,
+	"outcome":    trOutcome,
 	"sampled":    true,
 	"trace_id":   traceID,
 	"parent_id":  parentID,
@@ -118,6 +120,10 @@ func TestDecodeTransactionInvalid(t *testing.T) {
 			input: map[string]interface{}{"duration": -1.0},
 			err:   "duration.*must be >= 0 but found -1",
 		},
+		"invalid outcome": {
+			input: map[string]interface{}{"outcome": `¯\_(ツ)_/¯`},
+			err:   `outcome.*must be one of <nil>, "success", "failure", "unknown"`,
+		},
 	} {
 		t.Run(name, func(t *testing.T) {
 			input := make(map[string]interface{})
@@ -164,6 +170,7 @@ func TestTransactionDecodeRUMV3Marks(t *testing.T) {
 
 func TestTransactionEventDecode(t *testing.T) {
 	id, trType, name, result := "123", "type", "foo()", "555"
+	outcome := "success"
 	requestTime := time.Now()
 	timestampParsed := time.Date(2017, 5, 30, 18, 53, 27, 154*1e6, time.UTC)
 	timestampEpoch := json.Number(fmt.Sprintf("%d", timestampParsed.UnixNano()/1000))
@@ -299,6 +306,7 @@ func TestTransactionEventDecode(t *testing.T) {
 			input: map[string]interface{}{
 				"timestamp": timestampEpoch,
 				"result":    result,
+				"outcome":   outcome,
 				"sampled":   sampled,
 				"parent_id": parentID,
 				"marks":     marks,
@@ -325,6 +333,7 @@ func TestTransactionEventDecode(t *testing.T) {
 				Type:      trType,
 				Name:      name,
 				Result:    result,
+				Outcome:   outcome,
 				ParentID:  parentID,
 				TraceID:   traceID,
 				Duration:  duration,