Method RunStepsV2

internal/route/route.go:246–390

(req *Request, rec recorder, log *zap.Logger, kc *key.ResponseKey)

}

func (r *Route) RunStepsV2(req *Request, rec recorder, log *zap.Logger, kc *key.ResponseKey) (*Response, error) {
	if len(r.Steps) == 0 {
		return nil, errors.New("steps are empty")
	}

	body, err := io.ReadAll(req.Forwarded.Body)
	if err != nil {
		return nil, err
	}

	events := []*event.Event{}
	response := &Response{}

	for _, step := range r.Steps {
		dur := time.Second
		if len(step.RetryInterval) != 0 {
			parsed, err := time.ParseDuration(step.RetryInterval)
			if err != nil {
				return nil, err
			}

			dur = parsed
		}

		b := InitializeBackoff(r.RetryStrategy, dur)
		withRetries := backoff.WithMaxRetries(b, uint64(step.Retries))

		do := func() error {
			start := time.Now()

			evt := &event.Event{
				Id:            util.NewUuid(),
				CreatedAt:     time.Now().Unix(),
				Tags:          kc.Tags,
				KeyId:         kc.KeyId,
				Provider:      step.Provider,
				Method:        req.Forwarded.Method,
				Path:          req.Forwarded.URL.Path,
				Model:         step.Model,
				Action:        req.Action,
				Request:       []byte(`{}`),
				Response:      []byte(`{}`),
				CustomId:      req.Forwarded.Header.Get("X-CUSTOM-EVENT-ID"),
				UserId:        req.UserId,
				PolicyId:      req.PolicyId,
				RouteId:       r.Id,
				CorrelationId: req.CorrelationId,
			}

			defer func() {
				evt.LatencyInMs = int(time.Since(start).Milliseconds())
			}()

			events = append(events, evt)

			if kc.ShouldLogRequest {
				evt.Request = body
			}