mirror of
https://github.com/hanzoai/o11y.git
synced 2026-10-15 12:58:33 +00:00
zeekayandHanzo Dev
d8a5046dab
Twenty-nine handler bodies across six packages named gorilla/mux to read a path
segment, so the router was braided into the rule, alert, trace and sentry logic
that addresses a resource by id. The value each one needs is the SEGMENT; which
router matched the route is not a fact these handlers should hold. All twenty-
nine now read through coretypes.Param — the one route-value reader — and the
tracefunnel test's two injectors through coretypes.SetParams, its writer half.
A PATH segment and a QUERY value stay apart, because that is the failure this
seam exists to prevent: r.URL.Query().Get is untouched everywhere it appears
(the history window, sentry's ?project=, the funnel limits), and three of the
new tests pin it by sending a query value of the SAME name as the path segment
and asserting the path still answers.
Two helpers, both deleting real duplication rather than adding a second reader:
o11yruler.idFromPath replaces the same five-line uuid-v7 block written out
seven times, and o11yalertmanager.channelIDFromPath replaces a seventeen-line
nil-map/ok/parse dance written out three times. Absent and malformed remain
DIFFERENT refusals in the alertmanager one — "id is required in path" vs "id is
not a valid uuid-v7" — which is what the code it replaces answered.
Eleven new tests, and they are not vacuous. Each drives a REAL router at the
REAL template — /v1/o11y/rules/{id}/history/stats, /v1/o11y/channels/{id},
/v1/o11y/traces/{traceID}/waterfall, /v1/sentry/events/{id}, the uuid-
constrained /v1/sentry/{project}/envelope/ — and asserts the MODULE was asked
about what the router matched, so a passing test needs the whole path from
route table to business call. Stubbing Param to "" (go test -overlay, so the
shared tree is never mutated) turns all six packages RED; before these tests
five of them had no test that touched a param at all.
Registration is untouched: no {id} literal, no *mux.Router, no .Methods() moved.
Route table unchanged — TestEveryRouteIsNamedAndCounted still passes at 367.
Co-authored-by: Hanzo Dev <[email protected]>
337 lines
8.1 KiB
Go
337 lines
8.1 KiB
Go
package o11yruler
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/hanzoai/o11y/pkg/errors"
|
|
"github.com/hanzoai/o11y/pkg/http/binding"
|
|
"github.com/hanzoai/o11y/pkg/http/render"
|
|
"github.com/hanzoai/o11y/pkg/ruler"
|
|
"github.com/hanzoai/o11y/pkg/types/alertmanagertypes"
|
|
"github.com/hanzoai/o11y/pkg/types/authtypes"
|
|
"github.com/hanzoai/o11y/pkg/types/coretypes"
|
|
"github.com/hanzoai/o11y/pkg/types/ruletypes"
|
|
"github.com/hanzoai/o11y/pkg/valuer"
|
|
)
|
|
|
|
type handler struct {
|
|
ruler ruler.Ruler
|
|
}
|
|
|
|
func NewHandler(ruler ruler.Ruler) ruler.Handler {
|
|
return &handler{ruler: ruler}
|
|
}
|
|
|
|
func (handler *handler) ListRules(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
rules, err := handler.ruler.ListRuleStates(ctx)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
view := make([]*ruletypes.Rule, 0, len(rules.Rules))
|
|
for _, rule := range rules.Rules {
|
|
view = append(view, ruletypes.NewRule(rule))
|
|
}
|
|
|
|
render.Success(rw, http.StatusOK, view)
|
|
}
|
|
|
|
func (handler *handler) GetRuleByID(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
id, err := idFromPath(req)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
rule, err := handler.ruler.GetRule(ctx, id)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusOK, ruletypes.NewRule(rule))
|
|
}
|
|
|
|
func (handler *handler) CreateRule(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
body, err := io.ReadAll(req.Body)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
defer req.Body.Close() //nolint:errcheck
|
|
|
|
rule, err := handler.ruler.CreateRule(ctx, string(body))
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusCreated, ruletypes.NewRule(rule))
|
|
}
|
|
|
|
func (handler *handler) UpdateRuleByID(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
id, err := idFromPath(req)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
body, err := io.ReadAll(req.Body)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
defer req.Body.Close() //nolint:errcheck
|
|
|
|
err = handler.ruler.EditRule(ctx, string(body), id)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusNoContent, nil)
|
|
}
|
|
|
|
func (handler *handler) DeleteRuleByID(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
id, err := idFromPath(req)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
err = handler.ruler.DeleteRule(ctx, id.StringValue())
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusNoContent, nil)
|
|
}
|
|
|
|
func (handler *handler) PatchRuleByID(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
id, err := idFromPath(req)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
body, err := io.ReadAll(req.Body)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
defer req.Body.Close() //nolint:errcheck
|
|
|
|
rule, err := handler.ruler.PatchRule(ctx, string(body), id)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusOK, ruletypes.NewRule(rule))
|
|
}
|
|
|
|
func (handler *handler) TestRule(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 1*time.Minute)
|
|
defer cancel()
|
|
|
|
claims, err := authtypes.ClaimsFromContext(ctx)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
orgID, err := valuer.NewUUID(claims.OrgID)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
body, err := io.ReadAll(req.Body)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
defer req.Body.Close() //nolint:errcheck
|
|
|
|
alertCount, err := handler.ruler.TestNotification(ctx, orgID, string(body))
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusOK, ruletypes.GettableTestRule{AlertCount: alertCount, Message: "notification sent"})
|
|
}
|
|
|
|
func (handler *handler) ListDowntimeSchedules(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
claims, err := authtypes.ClaimsFromContext(ctx)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
var params alertmanagertypes.ListPlannedMaintenanceParams
|
|
if err := binding.Query.BindQuery(req.URL.Query(), ¶ms); err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
schedules, err := handler.ruler.MaintenanceStore().ListPlannedMaintenance(ctx, claims.OrgID)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
if params.Active != nil {
|
|
activeSchedules := make([]*alertmanagertypes.PlannedMaintenance, 0)
|
|
for _, schedule := range schedules {
|
|
now := time.Now().In(time.FixedZone(schedule.Schedule.Timezone, 0))
|
|
if schedule.IsActive(now) == *params.Active {
|
|
activeSchedules = append(activeSchedules, schedule)
|
|
}
|
|
}
|
|
schedules = activeSchedules
|
|
}
|
|
|
|
if params.Recurring != nil {
|
|
recurringSchedules := make([]*alertmanagertypes.PlannedMaintenance, 0)
|
|
for _, schedule := range schedules {
|
|
if schedule.IsRecurring() == *params.Recurring {
|
|
recurringSchedules = append(recurringSchedules, schedule)
|
|
}
|
|
}
|
|
schedules = recurringSchedules
|
|
}
|
|
|
|
render.Success(rw, http.StatusOK, schedules)
|
|
}
|
|
|
|
func (handler *handler) GetDowntimeScheduleByID(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
id, err := idFromPath(req)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
schedule, err := handler.ruler.MaintenanceStore().GetPlannedMaintenanceByID(ctx, id)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusOK, schedule)
|
|
}
|
|
|
|
func (handler *handler) CreateDowntimeSchedule(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
schedule := new(alertmanagertypes.PostablePlannedMaintenance)
|
|
if err := binding.JSON.BindBody(req.Body, schedule); err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
if err := schedule.Validate(); err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
created, err := handler.ruler.MaintenanceStore().CreatePlannedMaintenance(ctx, schedule)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusCreated, created)
|
|
}
|
|
|
|
func (handler *handler) UpdateDowntimeScheduleByID(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
id, err := idFromPath(req)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
schedule := new(alertmanagertypes.PostablePlannedMaintenance)
|
|
if err := binding.JSON.BindBody(req.Body, schedule); err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
if err := schedule.Validate(); err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
err = handler.ruler.MaintenanceStore().UpdatePlannedMaintenance(ctx, schedule, id)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusNoContent, nil)
|
|
}
|
|
|
|
func (handler *handler) DeleteDowntimeScheduleByID(rw http.ResponseWriter, req *http.Request) {
|
|
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
id, err := idFromPath(req)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
err = handler.ruler.MaintenanceStore().DeletePlannedMaintenance(ctx, id)
|
|
if err != nil {
|
|
render.Error(rw, err)
|
|
return
|
|
}
|
|
|
|
render.Success(rw, http.StatusNoContent, nil)
|
|
}
|
|
|
|
// idFromPath reads the {id} PATH segment — a rule's on /v1/o11y/rules/{id}, a
|
|
// schedule's on /v1/o11y/downtime_schedules/{id} — and validates it as a
|
|
// uuid-v7. The read goes through coretypes.Param, the ONE route-value reader, so
|
|
// these handlers name the value they need and not the router that matched it.
|
|
func idFromPath(req *http.Request) (valuer.UUID, error) {
|
|
id, err := valuer.NewUUID(coretypes.Param(req, "id"))
|
|
if err != nil {
|
|
return valuer.UUID{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7")
|
|
}
|
|
return id, nil
|
|
}
|