func mapToTransactionModel()

in input/elasticapm/internal/modeldecoder/rumv3/decoder.go [700:872]
168 lines of code
48 McCabe index (conditional complexity)

func mapToTransactionModel(from *transaction, event *modelpb.APMEvent) {
	out := modelpb.Transaction{}
	out.Type = "unknown"
	event.Transaction = &out

	// overwrite metadata with event specific information
	if from.Context.Service.IsSet() {
		if event.Service == nil {
			event.Service = &modelpb.Service{}
		}
		mapToServiceModel(from.Context.Service, event.Service)
	}
	if from.Context.Service.Agent.IsSet() {
		if event.Agent == nil {
			event.Agent = &modelpb.Agent{}
		}
		mapToAgentModel(from.Context.Service.Agent, event.Agent)
	}
	overwriteUserInMetadataModel(from.Context.User, event)
	if from.Context.Request.Headers.IsSet() {
		if event.UserAgent == nil {
			event.UserAgent = &modelpb.UserAgent{}
		}
		mapToUserAgentModel(from.Context.Request.Headers, event.UserAgent)
	}

	// map transaction specific data
	if from.Context.IsSet() {
		if len(from.Context.Custom) > 0 {
			out.Custom = modeldecoderutil.ToKv(from.Context.Custom, out.Custom)
		}
		if len(from.Context.Tags) > 0 {
			modeldecoderutil.MergeLabels(from.Context.Tags, event)
		}
		if from.Context.Request.IsSet() {
			if event.Http == nil {
				event.Http = &modelpb.HTTP{}
			}
			event.Http.Request = &modelpb.HTTPRequest{}
			mapToRequestModel(from.Context.Request, event.Http.Request)
			if from.Context.Request.HTTPVersion.IsSet() {
				event.Http.Version = from.Context.Request.HTTPVersion.Val
			}
		}
		if from.Context.Response.IsSet() {
			if event.Http == nil {
				event.Http = &modelpb.HTTP{}
			}
			event.Http.Response = &modelpb.HTTPResponse{}
			mapToResponseModel(from.Context.Response, event.Http.Response)
		}
		if from.Context.Page.IsSet() {
			if from.Context.Page.URL.IsSet() {
				event.Url = modelpb.ParseURL(from.Context.Page.URL.Val, "", "")
			}
			if from.Context.Page.Referer.IsSet() {
				if event.Http == nil {
					event.Http = &modelpb.HTTP{}
				}
				if event.Http.Request == nil {
					event.Http.Request = &modelpb.HTTPRequest{}
				}
				event.Http.Request.Referrer = from.Context.Page.Referer.Val
			}
		}
	}
	if from.Duration.IsSet() {
		if event.Event == nil {
			event.Event = &modelpb.Event{}
		}
		event.Event.Duration = uint64(from.Duration.Val * float64(time.Millisecond))
	}
	if from.ID.IsSet() {
		out.Id = from.ID.Val
	}
	if from.Marks.IsSet() {
		out.Marks = make(map[string]*modelpb.TransactionMark, len(from.Marks.Events))
		for event, val := range from.Marks.Events {
			if len(val.Measurements) > 0 {
				tm := modelpb.TransactionMark{}
				tm.Measurements = val.Measurements
				out.Marks[event] = &tm
			}
		}
	}
	if from.Name.IsSet() {
		out.Name = from.Name.Val
	}
	if event.Event == nil {
		event.Event = &modelpb.Event{}
	}
	if from.Outcome.IsSet() {
		event.Event.Outcome = from.Outcome.Val
	} else {
		if from.Context.Response.StatusCode.IsSet() {
			statusCode := from.Context.Response.StatusCode.Val
			if statusCode >= http.StatusInternalServerError {
				event.Event.Outcome = "failure"
			} else {
				event.Event.Outcome = "success"
			}
		} else {
			event.Event.Outcome = "unknown"
		}
	}
	if from.ParentID.IsSet() {
		event.ParentId = from.ParentID.Val
	}
	if from.Result.IsSet() {
		out.Result = from.Result.Val
	}

	sampled := true
	if from.Sampled.IsSet() {
		sampled = from.Sampled.Val
	}
	out.Sampled = sampled
	if from.SampleRate.IsSet() {
		if from.SampleRate.Val > 0 {
			out.RepresentativeCount = 1 / from.SampleRate.Val
		}
	} else {
		out.RepresentativeCount = 1
	}
	if from.Session.ID.IsSet() {
		event.Session = &modelpb.Session{}
		event.Session.Id = from.Session.ID.Val
		event.Session.Sequence = uint64(from.Session.Sequence.Val)
	}
	if from.SpanCount.Dropped.IsSet() {
		if out.SpanCount == nil {
			out.SpanCount = &modelpb.SpanCount{}
		}
		dropped := uint32(from.SpanCount.Dropped.Val)
		out.SpanCount.Dropped = &dropped
	}
	if from.SpanCount.Started.IsSet() {
		if out.SpanCount == nil {
			out.SpanCount = &modelpb.SpanCount{}
		}
		started := uint32(from.SpanCount.Started.Val)
		out.SpanCount.Started = &started
	}
	if from.TraceID.IsSet() {
		event.Trace = &modelpb.Trace{}
		event.Trace.Id = from.TraceID.Val
	}
	if from.Type.IsSet() {
		out.Type = from.Type.Val
	}
	if from.UserExperience.IsSet() {
		out.UserExperience = &modelpb.UserExperience{}
		out.UserExperience.CumulativeLayoutShift = -1
		out.UserExperience.FirstInputDelay = -1
		out.UserExperience.TotalBlockingTime = -1
		out.UserExperience.LongTask = nil
		if from.UserExperience.CumulativeLayoutShift.IsSet() {
			out.UserExperience.CumulativeLayoutShift = from.UserExperience.CumulativeLayoutShift.Val
		}
		if from.UserExperience.FirstInputDelay.IsSet() {
			out.UserExperience.FirstInputDelay = from.UserExperience.FirstInputDelay.Val
		}
		if from.UserExperience.TotalBlockingTime.IsSet() {
			out.UserExperience.TotalBlockingTime = from.UserExperience.TotalBlockingTime.Val
		}
		if from.UserExperience.Longtask.IsSet() {
			out.UserExperience.LongTask = &modelpb.LongtaskMetrics{}
			out.UserExperience.LongTask.Count = uint64(from.UserExperience.Longtask.Count.Val)
			out.UserExperience.LongTask.Sum = from.UserExperience.Longtask.Sum.Val
			out.UserExperience.LongTask.Max = from.UserExperience.Longtask.Max.Val
		}
	}
}