// Code generated by ogen, DO NOT EDIT. package api import ( "context" "net/http" "time" "github.com/go-faster/errors" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/metric" semconv "go.opentelemetry.io/otel/semconv/v1.26.0" "go.opentelemetry.io/otel/trace" ht "github.com/ogen-go/ogen/http" "github.com/ogen-go/ogen/middleware" "github.com/ogen-go/ogen/ogenerrors" "github.com/ogen-go/ogen/otelogen" ) type codeRecorder struct { http.ResponseWriter status int } func (c *codeRecorder) WriteHeader(status int) { c.status = status c.ResponseWriter.WriteHeader(status) } // handleActionMapfixAcceptedRequest handles actionMapfixAccepted operation. // // (Internal endpoint) Role Validator changes status from Validating -> Accepted. // // POST /mapfixes/{MapfixID}/status/validator-failed func (s *Server) handleActionMapfixAcceptedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionMapfixAccepted"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/mapfixes/{MapfixID}/status/validator-failed"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionMapfixAcceptedOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionMapfixAcceptedOperation, ID: "actionMapfixAccepted", } ) params, err := decodeActionMapfixAcceptedParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionMapfixAcceptedNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionMapfixAcceptedOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Validating -> Accepted", OperationID: "actionMapfixAccepted", Body: nil, Params: middleware.Parameters{ { Name: "MapfixID", In: "path", }: params.MapfixID, { Name: "StatusMessage", In: "query", }: params.StatusMessage, }, Raw: r, } type ( Request = struct{} Params = ActionMapfixAcceptedParams Response = *ActionMapfixAcceptedNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionMapfixAcceptedParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionMapfixAccepted(ctx, params) return response, err }, ) } else { err = s.h.ActionMapfixAccepted(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionMapfixAcceptedResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionMapfixUploadedRequest handles actionMapfixUploaded operation. // // (Internal endpoint) Role Validator changes status from Uploading -> Uploaded. // // POST /mapfixes/{MapfixID}/status/validator-uploaded func (s *Server) handleActionMapfixUploadedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionMapfixUploaded"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/mapfixes/{MapfixID}/status/validator-uploaded"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionMapfixUploadedOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionMapfixUploadedOperation, ID: "actionMapfixUploaded", } ) params, err := decodeActionMapfixUploadedParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionMapfixUploadedNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionMapfixUploadedOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Uploading -> Uploaded", OperationID: "actionMapfixUploaded", Body: nil, Params: middleware.Parameters{ { Name: "MapfixID", In: "path", }: params.MapfixID, }, Raw: r, } type ( Request = struct{} Params = ActionMapfixUploadedParams Response = *ActionMapfixUploadedNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionMapfixUploadedParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionMapfixUploaded(ctx, params) return response, err }, ) } else { err = s.h.ActionMapfixUploaded(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionMapfixUploadedResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionMapfixValidatedRequest handles actionMapfixValidated operation. // // (Internal endpoint) Role Validator changes status from Validating -> Validated. // // POST /mapfixes/{MapfixID}/status/validator-validated func (s *Server) handleActionMapfixValidatedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionMapfixValidated"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/mapfixes/{MapfixID}/status/validator-validated"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionMapfixValidatedOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionMapfixValidatedOperation, ID: "actionMapfixValidated", } ) params, err := decodeActionMapfixValidatedParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionMapfixValidatedNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionMapfixValidatedOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Validating -> Validated", OperationID: "actionMapfixValidated", Body: nil, Params: middleware.Parameters{ { Name: "MapfixID", In: "path", }: params.MapfixID, }, Raw: r, } type ( Request = struct{} Params = ActionMapfixValidatedParams Response = *ActionMapfixValidatedNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionMapfixValidatedParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionMapfixValidated(ctx, params) return response, err }, ) } else { err = s.h.ActionMapfixValidated(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionMapfixValidatedResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionAcceptedRequest handles actionSubmissionAccepted operation. // // (Internal endpoint) Role Validator changes status from Validating -> Accepted. // // POST /submissions/{SubmissionID}/status/validator-failed func (s *Server) handleActionSubmissionAcceptedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionAccepted"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/validator-failed"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionAcceptedOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionAcceptedOperation, ID: "actionSubmissionAccepted", } ) params, err := decodeActionSubmissionAcceptedParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionAcceptedNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionAcceptedOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Validating -> Accepted", OperationID: "actionSubmissionAccepted", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, { Name: "StatusMessage", In: "query", }: params.StatusMessage, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionAcceptedParams Response = *ActionSubmissionAcceptedNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionAcceptedParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionAccepted(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionAccepted(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionAcceptedResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionUploadedRequest handles actionSubmissionUploaded operation. // // (Internal endpoint) Role Validator changes status from Uploading -> Uploaded. // // POST /submissions/{SubmissionID}/status/validator-uploaded func (s *Server) handleActionSubmissionUploadedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionUploaded"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/validator-uploaded"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionUploadedOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionUploadedOperation, ID: "actionSubmissionUploaded", } ) params, err := decodeActionSubmissionUploadedParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionUploadedNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionUploadedOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Uploading -> Uploaded", OperationID: "actionSubmissionUploaded", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, { Name: "UploadedAssetID", In: "query", }: params.UploadedAssetID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionUploadedParams Response = *ActionSubmissionUploadedNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionUploadedParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionUploaded(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionUploaded(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionUploadedResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionValidatedRequest handles actionSubmissionValidated operation. // // (Internal endpoint) Role Validator changes status from Validating -> Validated. // // POST /submissions/{SubmissionID}/status/validator-validated func (s *Server) handleActionSubmissionValidatedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionValidated"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/validator-validated"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionValidatedOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionValidatedOperation, ID: "actionSubmissionValidated", } ) params, err := decodeActionSubmissionValidatedParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionValidatedNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionValidatedOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Validating -> Validated", OperationID: "actionSubmissionValidated", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionValidatedParams Response = *ActionSubmissionValidatedNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionValidatedParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionValidated(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionValidated(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionValidatedResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleCreateScriptRequest handles createScript operation. // // Create a new script. // // POST /scripts func (s *Server) handleCreateScriptRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("createScript"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/scripts"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), CreateScriptOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: CreateScriptOperation, ID: "createScript", } ) request, close, err := s.decodeCreateScriptRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response *ID if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: CreateScriptOperation, OperationSummary: "Create a new script", OperationID: "createScript", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( Request = *ScriptCreate Params = struct{} Response = *ID ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.CreateScript(ctx, request) return response, err }, ) } else { response, err = s.h.CreateScript(ctx, request) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeCreateScriptResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleCreateScriptPolicyRequest handles createScriptPolicy operation. // // Create a new script policy. // // POST /script-policy func (s *Server) handleCreateScriptPolicyRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("createScriptPolicy"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/script-policy"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), CreateScriptPolicyOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: CreateScriptPolicyOperation, ID: "createScriptPolicy", } ) request, close, err := s.decodeCreateScriptPolicyRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response *ID if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: CreateScriptPolicyOperation, OperationSummary: "Create a new script policy", OperationID: "createScriptPolicy", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( Request = *ScriptPolicyCreate Params = struct{} Response = *ID ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.CreateScriptPolicy(ctx, request) return response, err }, ) } else { response, err = s.h.CreateScriptPolicy(ctx, request) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeCreateScriptPolicyResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleGetScriptRequest handles getScript operation. // // Get the specified script by ID. // // GET /scripts/{ScriptID} func (s *Server) handleGetScriptRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getScript"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/scripts/{ScriptID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), GetScriptOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: GetScriptOperation, ID: "getScript", } ) params, err := decodeGetScriptParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *Script if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: GetScriptOperation, OperationSummary: "Get the specified script by ID", OperationID: "getScript", Body: nil, Params: middleware.Parameters{ { Name: "ScriptID", In: "path", }: params.ScriptID, }, Raw: r, } type ( Request = struct{} Params = GetScriptParams Response = *Script ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackGetScriptParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.GetScript(ctx, params) return response, err }, ) } else { response, err = s.h.GetScript(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeGetScriptResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleListScriptPolicyRequest handles listScriptPolicy operation. // // Get list of script policies. // // GET /script-policy func (s *Server) handleListScriptPolicyRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("listScriptPolicy"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/script-policy"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ListScriptPolicyOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ListScriptPolicyOperation, ID: "listScriptPolicy", } ) params, err := decodeListScriptPolicyParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response []ScriptPolicy if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ListScriptPolicyOperation, OperationSummary: "Get list of script policies", OperationID: "listScriptPolicy", Body: nil, Params: middleware.Parameters{ { Name: "Page", In: "query", }: params.Page, { Name: "Limit", In: "query", }: params.Limit, { Name: "FromScriptHash", In: "query", }: params.FromScriptHash, { Name: "ToScriptID", In: "query", }: params.ToScriptID, { Name: "Policy", In: "query", }: params.Policy, }, Raw: r, } type ( Request = struct{} Params = ListScriptPolicyParams Response = []ScriptPolicy ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackListScriptPolicyParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.ListScriptPolicy(ctx, params) return response, err }, ) } else { response, err = s.h.ListScriptPolicy(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeListScriptPolicyResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleListScriptsRequest handles listScripts operation. // // Get list of scripts. // // GET /scripts func (s *Server) handleListScriptsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("listScripts"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/scripts"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ListScriptsOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ListScriptsOperation, ID: "listScripts", } ) params, err := decodeListScriptsParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response []Script if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ListScriptsOperation, OperationSummary: "Get list of scripts", OperationID: "listScripts", Body: nil, Params: middleware.Parameters{ { Name: "Page", In: "query", }: params.Page, { Name: "Limit", In: "query", }: params.Limit, { Name: "Hash", In: "query", }: params.Hash, { Name: "Name", In: "query", }: params.Name, { Name: "Source", In: "query", }: params.Source, { Name: "ResourceType", In: "query", }: params.ResourceType, { Name: "ResourceID", In: "query", }: params.ResourceID, }, Raw: r, } type ( Request = struct{} Params = ListScriptsParams Response = []Script ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackListScriptsParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.ListScripts(ctx, params) return response, err }, ) } else { response, err = s.h.ListScripts(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeListScriptsResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleUpdateMapfixValidatedModelRequest handles updateMapfixValidatedModel operation. // // Update validated model. // // POST /mapfixes/{MapfixID}/validated-model func (s *Server) handleUpdateMapfixValidatedModelRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("updateMapfixValidatedModel"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/mapfixes/{MapfixID}/validated-model"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), UpdateMapfixValidatedModelOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: UpdateMapfixValidatedModelOperation, ID: "updateMapfixValidatedModel", } ) params, err := decodeUpdateMapfixValidatedModelParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *UpdateMapfixValidatedModelNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: UpdateMapfixValidatedModelOperation, OperationSummary: "Update validated model", OperationID: "updateMapfixValidatedModel", Body: nil, Params: middleware.Parameters{ { Name: "MapfixID", In: "path", }: params.MapfixID, { Name: "ValidatedModelID", In: "query", }: params.ValidatedModelID, { Name: "ValidatedModelVersion", In: "query", }: params.ValidatedModelVersion, }, Raw: r, } type ( Request = struct{} Params = UpdateMapfixValidatedModelParams Response = *UpdateMapfixValidatedModelNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackUpdateMapfixValidatedModelParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.UpdateMapfixValidatedModel(ctx, params) return response, err }, ) } else { err = s.h.UpdateMapfixValidatedModel(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeUpdateMapfixValidatedModelResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleUpdateSubmissionValidatedModelRequest handles updateSubmissionValidatedModel operation. // // Update validated model. // // POST /submissions/{SubmissionID}/validated-model func (s *Server) handleUpdateSubmissionValidatedModelRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("updateSubmissionValidatedModel"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/validated-model"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), UpdateSubmissionValidatedModelOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: UpdateSubmissionValidatedModelOperation, ID: "updateSubmissionValidatedModel", } ) params, err := decodeUpdateSubmissionValidatedModelParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *UpdateSubmissionValidatedModelNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: UpdateSubmissionValidatedModelOperation, OperationSummary: "Update validated model", OperationID: "updateSubmissionValidatedModel", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, { Name: "ValidatedModelID", In: "query", }: params.ValidatedModelID, { Name: "ValidatedModelVersion", In: "query", }: params.ValidatedModelVersion, }, Raw: r, } type ( Request = struct{} Params = UpdateSubmissionValidatedModelParams Response = *UpdateSubmissionValidatedModelNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackUpdateSubmissionValidatedModelParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.UpdateSubmissionValidatedModel(ctx, params) return response, err }, ) } else { err = s.h.UpdateSubmissionValidatedModel(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeUpdateSubmissionValidatedModelResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } }