Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
icmp check (#2405)
Thibault Le Ouay9643ad610bcf
diff --git a/apps/checker/checker/icmp.go b/apps/checker/checker/icmp.gonew file mode 100644index 000000000..f13393777--- /dev/null+++ b/apps/checker/checker/icmp.go@@ -0,0 +1,291 @@+package checker++import (+ "fmt"+ "net"+ "os"+ "sync/atomic"+ "time"++ "golang.org/x/net/icmp"+ "golang.org/x/net/ipv4"+ "golang.org/x/net/ipv6"+)++// icmpEchoCounter hands each probe its own echo identifier. A raw socket+// receives every ICMP packet delivered to the host, so probes are told apart by+// the echo id alone; a per-process value (the pid) makes two concurrent probes+// to the same target indistinguishable. Seeded from the pid so a restart does+// not immediately reuse the ids of packets still in flight.+var icmpEchoCounter = func() *atomic.Uint32 {+ var c atomic.Uint32+ c.Store(uint32(os.Getpid()))+ return &c+}()++func nextEchoID() int {+ return int(icmpEchoCounter.Add(1) & 0xffff)+}++const (+ icmpPacketCount = 3+ icmpPacketInterval = 100 * time.Millisecond+ // Applied when a caller omits the timeout. Without it the deadline below+ // lands in the past, the send loop breaks before the first packet, and the+ // check reports "no reply" having probed nothing.+ icmpDefaultTimeout = 45_000+)++type ICMPResponseTiming struct {+ // RTTs holds one entry per sent packet in send order; -1 marks a lost packet.+ RTTs []int64 `json:"rtts"`+}++type ICMPResult struct {+ Timing ICMPResponseTiming+ Latency int64+ LatencyMin int64+ LatencyMax int64+ PacketsSent uint8+ PacketsReceived uint8+}++type ICMPResponse struct {+ Region string `json:"region"`+ ErrorMessage string `json:"errorMessage"`+ JobType string `json:"jobType"`+ RequestId int64 `json:"requestId,omitempty"`+ WorkspaceID int64 `json:"workspaceId"`+ MonitorID int64 `json:"monitorId"`+ Timestamp int64 `json:"timestamp"`+ Latency int64 `json:"latency"`+ LatencyMin int64 `json:"latencyMin"`+ LatencyMax int64 `json:"latencyMax"`+ PacketsSent uint8 `json:"packetsSent"`+ PacketsReceived uint8 `json:"packetsReceived"`+ Timing ICMPResponseTiming `json:"timing"`+ Error uint8 `json:"error,omitempty"`+}++func PingICMP(timeoutMs int64, hostname string) (ICMPResult, error) {+ if timeoutMs <= 0 {+ timeoutMs = icmpDefaultTimeout+ }++ dst, err := net.ResolveIPAddr("ip", hostname)+ if err != nil {+ return ICMPResult{}, fmt.Errorf("resolve error: %w", err)+ }++ var (+ udpNetwork string+ rawNetwork string+ proto int+ echoType icmp.Type+ )+ if dst.IP.To4() != nil {+ udpNetwork, rawNetwork, proto, echoType = "udp4", "ip4:icmp", ipv4.ICMPTypeEcho.Protocol(), ipv4.ICMPTypeEcho+ } else {+ udpNetwork, rawNetwork, proto, echoType = "udp6", "ip6:ipv6-icmp", ipv6.ICMPTypeEchoRequest.Protocol(), ipv6.ICMPTypeEchoRequest+ }++ conn, isRaw, err := listenICMP(udpNetwork, rawNetwork)+ if err != nil {+ return ICMPResult{}, fmt.Errorf("icmp socket error: %w", err)+ }+ defer conn.Close()++ deadline := time.Now().Add(time.Duration(timeoutMs) * time.Millisecond)+ id := nextEchoID()++ timing := ICMPResponseTiming{RTTs: make([]int64, 0, icmpPacketCount)}+ received := make([]int64, 0, icmpPacketCount)+ var packetsSent uint8+ var lastErr error++ for seq := 0; seq < icmpPacketCount; seq++ {+ if seq > 0 {+ time.Sleep(icmpPacketInterval)+ }++ remaining := time.Until(deadline)+ if remaining <= 0 {+ break+ }+ perPacket := remaining / time.Duration(icmpPacketCount-seq)+ packetsSent++++ rtt, err := sendEcho(conn, isRaw, proto, echoType, dst, id, seq, time.Now().Add(perPacket))+ if err != nil {+ lastErr = err+ timing.RTTs = append(timing.RTTs, -1)+ continue+ }+ timing.RTTs = append(timing.RTTs, rtt)+ received = append(received, rtt)+ }++ if len(received) == 0 {+ if lastErr != nil {+ return ICMPResult{}, lastErr+ }+ return ICMPResult{}, fmt.Errorf("no reply from %s", hostname)+ }++ var sum, min, max int64+ for i, rtt := range received {+ sum += rtt+ if i == 0 || rtt < min {+ min = rtt+ }+ if i == 0 || rtt > max {+ max = rtt+ }+ }++ return ICMPResult{+ Timing: timing,+ Latency: sum / int64(len(received)),+ LatencyMin: min,+ LatencyMax: max,+ PacketsSent: packetsSent,+ PacketsReceived: uint8(len(received)),+ }, nil+}++// listenICMP prefers an unprivileged datagram socket and falls back to a raw+// socket when the runtime lacks ping_group_range but holds CAP_NET_RAW.+func listenICMP(udpNetwork, rawNetwork string) (*icmp.PacketConn, bool, error) {+ udpBind, rawBind := "0.0.0.0", "0.0.0.0"+ if udpNetwork == "udp6" {+ udpBind, rawBind = "::", "::"+ }++ conn, err := icmp.ListenPacket(udpNetwork, udpBind)+ if err == nil {+ return conn, false, nil+ }++ rawConn, rawErr := icmp.ListenPacket(rawNetwork, rawBind)+ if rawErr != nil {+ return nil, false, fmt.Errorf("udp: %v, raw: %w", err, rawErr)+ }+ return rawConn, true, nil+}++func sendEcho(conn *icmp.PacketConn, isRaw bool, proto int, echoType icmp.Type, dst *net.IPAddr, id, seq int, deadline time.Time) (int64, error) {+ var writeAddr net.Addr = &net.UDPAddr{IP: dst.IP, Zone: dst.Zone}+ if isRaw {+ writeAddr = &net.IPAddr{IP: dst.IP, Zone: dst.Zone}+ }++ msg := icmp.Message{+ Type: echoType,+ Code: 0,+ Body: &icmp.Echo{ID: id, Seq: seq, Data: []byte("openstatus")},+ }+ wb, err := msg.Marshal(nil)+ if err != nil {+ return 0, fmt.Errorf("marshal error: %w", err)+ }++ if err := conn.SetDeadline(deadline); err != nil {+ return 0, err+ }++ start := time.Now()+ if _, err := conn.WriteTo(wb, writeAddr); err != nil {+ return 0, fmt.Errorf("write error: %w", err)+ }++ rb := make([]byte, 1500)+ for {+ n, peer, err := conn.ReadFrom(rb)+ if err != nil {+ if ne, ok := err.(net.Error); ok && ne.Timeout() {+ return 0, fmt.Errorf("timeout")+ }+ return 0, fmt.Errorf("read error: %w", err)+ }++ rm, err := icmp.ParseMessage(proto, rb[:n])+ if err != nil {+ continue+ }++ switch body := rm.Body.(type) {+ case *icmp.Echo:+ // A reply to our probe can only come from the target. A raw socket+ // is not demultiplexed the way the datagram path is, so without+ // this it also sees replies belonging to other probes.+ if !addrIP(peer).Equal(dst.IP) {+ continue+ }+ // The kernel rewrites the Echo ID on datagram sockets, so only raw+ // sockets can trust it; datagram replies are matched on Seq alone.+ if body.Seq != seq || (isRaw && body.ID != id) {+ continue+ }+ return time.Since(start).Milliseconds(), nil+ case *icmp.DstUnreach:+ // Errors come from whichever hop rejected the packet, not from the+ // target, so the peer says nothing about ownership — the quoted+ // datagram does.+ if !provokedByProbe(body.Data, proto, id, seq, isRaw) {+ continue+ }+ return 0, fmt.Errorf("destination unreachable")+ case *icmp.TimeExceeded:+ if !provokedByProbe(body.Data, proto, id, seq, isRaw) {+ continue+ }+ return 0, fmt.Errorf("time exceeded")+ }+ }+}++// addrIP pulls the IP out of the address shape each socket type reports:+// *net.IPAddr for raw, *net.UDPAddr for the unprivileged datagram path.+func addrIP(addr net.Addr) net.IP {+ switch a := addr.(type) {+ case *net.IPAddr:+ return a.IP+ case *net.UDPAddr:+ return a.IP+ }+ return nil+}++// provokedByProbe reports whether an ICMP error quotes the packet we sent. The+// error carries the original datagram — IP header plus at least its first eight+// bytes, which is the whole echo header — so the quoted id and sequence+// identify the sender. Without this a raw socket would treat an unrelated+// flow's "destination unreachable" as its own probe failing.+func provokedByProbe(data []byte, proto, id, seq int, isRaw bool) bool {+ var quoted []byte+ switch proto {+ case ipv4.ICMPTypeEcho.Protocol():+ h, err := icmp.ParseIPv4Header(data)+ if err != nil || len(data) < h.Len {+ return false+ }+ quoted = data[h.Len:]+ default:+ if len(data) < ipv6.HeaderLen {+ return false+ }+ quoted = data[ipv6.HeaderLen:]+ }++ msg, err := icmp.ParseMessage(proto, quoted)+ if err != nil {+ return false+ }+ echo, ok := msg.Body.(*icmp.Echo)+ if !ok {+ return false+ }+ // Same asymmetry as the echo path: the kernel owns the id on datagram+ // sockets, so only raw probes can match on it.+ return echo.Seq == seq && (!isRaw || echo.ID == id)+}diff --git a/apps/checker/checker/icmp_internal_test.go b/apps/checker/checker/icmp_internal_test.gonew file mode 100644index 000000000..2f5a110a4--- /dev/null+++ b/apps/checker/checker/icmp_internal_test.go@@ -0,0 +1,149 @@+package checker++import (+ "net"+ "sync"+ "testing"++ "golang.org/x/net/icmp"+ "golang.org/x/net/ipv4"+ "golang.org/x/net/ipv6"+)++func TestNextEchoID_DistinguishesConcurrentProbes(t *testing.T) {+ // A raw socket tells probes apart by echo id alone, so two probes running+ // at once must never share one — a per-process id (the pid) did.+ const n = 512++ var wg sync.WaitGroup+ ids := make([]int, n)+ for i := range n {+ wg.Add(1)+ go func() {+ defer wg.Done()+ ids[i] = nextEchoID()+ }()+ }+ wg.Wait()++ seen := make(map[int]struct{}, n)+ for _, id := range ids {+ if _, dup := seen[id]; dup {+ t.Fatalf("nextEchoID() handed out %d twice across %d concurrent probes", id, n)+ }+ seen[id] = struct{}{}+ if id < 0 || id > 0xffff {+ t.Errorf("nextEchoID() = %d, outside the 16-bit echo id field", id)+ }+ }+}++func TestAddrIP(t *testing.T) {+ ip := net.ParseIP("192.0.2.7")++ for _, tc := range []struct {+ name string+ addr net.Addr+ want net.IP+ }{+ {name: "raw socket", addr: &net.IPAddr{IP: ip}, want: ip},+ {name: "datagram socket", addr: &net.UDPAddr{IP: ip}, want: ip},+ {name: "unknown shape", addr: &net.TCPAddr{IP: ip}, want: nil},+ {name: "nil", addr: nil, want: nil},+ } {+ t.Run(tc.name, func(t *testing.T) {+ got := addrIP(tc.addr)+ if !got.Equal(tc.want) {+ t.Errorf("addrIP() = %v, want %v", got, tc.want)+ }+ // An unrecognised address must never be mistaken for the target.+ if tc.want == nil && got.Equal(ip) {+ t.Error("addrIP() matched the target for an address it cannot read")+ }+ })+ }+}++// quotedError builds the payload an ICMP error carries: the original IP header+// followed by the datagram that provoked it.+func quotedError(t *testing.T, v4 bool, id, seq int) []byte {+ t.Helper()++ echoType := icmp.Type(ipv4.ICMPTypeEcho)+ if !v4 {+ echoType = ipv6.ICMPTypeEchoRequest+ }+ echo, err := (&icmp.Message{+ Type: echoType,+ Body: &icmp.Echo{ID: id, Seq: seq, Data: []byte("openstatus")},+ }).Marshal(nil)+ if err != nil {+ t.Fatalf("marshal echo: %v", err)+ }++ if v4 {+ // Minimal 20-byte IPv4 header; only the length nibble is read back.+ header := make([]byte, 20)+ header[0] = 0x45+ return append(header, echo...)+ }+ return append(make([]byte, ipv6.HeaderLen), echo...)+}++func TestProvokedByProbe(t *testing.T) {+ const (+ v4proto = 1 // ipv4.ICMPTypeEcho.Protocol()+ id = 4242+ seq = 1+ )++ t.Run("accepts the error quoting our own probe", func(t *testing.T) {+ data := quotedError(t, true, id, seq)+ if !provokedByProbe(data, v4proto, id, seq, true) {+ t.Error("provokedByProbe() rejected an error quoting this probe")+ }+ })++ t.Run("rejects another probe's error on the raw path", func(t *testing.T) {+ // The cross-talk case: same sequence (0/1/2 are always reused), a+ // different probe's id. A raw socket sees this packet too.+ data := quotedError(t, true, id+1, seq)+ if provokedByProbe(data, v4proto, id, seq, true) {+ t.Error("provokedByProbe() accepted an error belonging to another probe")+ }+ })++ t.Run("rejects a different sequence", func(t *testing.T) {+ data := quotedError(t, true, id, seq+1)+ if provokedByProbe(data, v4proto, id, seq, true) {+ t.Error("provokedByProbe() accepted an error for a different packet")+ }+ })++ t.Run("ignores the id on the datagram path", func(t *testing.T) {+ // The kernel rewrites the id on datagram sockets, so the quoted value+ // is not ours — but that socket is demultiplexed, so seq is enough.+ data := quotedError(t, true, id+1, seq)+ if !provokedByProbe(data, v4proto, id, seq, false) {+ t.Error("provokedByProbe() matched on an id the kernel owns")+ }+ })++ t.Run("rejects a truncated or unparsable quote", func(t *testing.T) {+ for _, data := range [][]byte{nil, {}, {0x45}, make([]byte, 20)} {+ if provokedByProbe(data, v4proto, id, seq, true) {+ t.Errorf("provokedByProbe() accepted an unusable quote %v", data)+ }+ }+ })++ t.Run("handles ipv6", func(t *testing.T) {+ const v6proto = 58 // ipv6.ICMPTypeEchoRequest.Protocol()+ if !provokedByProbe(quotedError(t, false, id, seq), v6proto, id, seq, true) {+ t.Error("provokedByProbe() rejected a v6 error quoting this probe")+ }+ if provokedByProbe(quotedError(t, false, id+1, seq), v6proto, id, seq, true) {+ t.Error("provokedByProbe() accepted another v6 probe's error")+ }+ })+}diff --git a/apps/checker/checker/icmp_test.go b/apps/checker/checker/icmp_test.gonew file mode 100644index 000000000..86b4f8540--- /dev/null+++ b/apps/checker/checker/icmp_test.go@@ -0,0 +1,70 @@+package checker_test++import (+ "strings"+ "testing"++ "github.com/openstatushq/openstatus/apps/checker/checker"+)++// skipIfNoICMP skips when the runtime cannot open an ICMP socket at all+// (unprivileged Linux CI without ping_group_range). macOS grants udp4 natively.+func skipIfNoICMP(t *testing.T, err error) {+ t.Helper()+ if err != nil && strings.Contains(err.Error(), "icmp socket error") {+ t.Skipf("icmp sockets unavailable in this environment: %v", err)+ }+}++func TestPingICMP_Loopback(t *testing.T) {+ res, err := checker.PingICMP(2000, "127.0.0.1")+ skipIfNoICMP(t, err)+ if err != nil {+ t.Fatalf("PingICMP() error = %v", err)+ }+ if res.PacketsReceived == 0 {+ t.Fatalf("PingICMP() received no packets: %+v", res)+ }+ if res.PacketsSent < res.PacketsReceived {+ t.Fatalf("PingICMP() received more than sent: %+v", res)+ }+ if res.LatencyMin > res.LatencyMax {+ t.Fatalf("PingICMP() min > max: %+v", res)+ }+ if len(res.Timing.RTTs) == 0 {+ t.Fatalf("PingICMP() empty timing: %+v", res)+ }+}++func TestPingICMP_ResolveError(t *testing.T) {+ _, err := checker.PingICMP(1000, "nonexistent-host-openstatus-test.invalid")+ if err == nil {+ t.Fatal("PingICMP() expected a resolve error, got nil")+ }+}++func TestPingICMP_Timeout(t *testing.T) {+ // 192.0.2.1 is TEST-NET-1 (RFC 5737): routable-looking but never answers.+ res, err := checker.PingICMP(1000, "192.0.2.1")+ skipIfNoICMP(t, err)+ if err == nil {+ t.Fatalf("PingICMP() expected timeout error, got %+v", res)+ }+}++// A zero timeout used to make the deadline land in the past, so the send loop+// broke before the first packet and every check reported "no reply" without+// probing. Callers that omit the field must still get a real check.+func TestPingICMP_ZeroTimeoutStillProbes(t *testing.T) {+ res, err := checker.PingICMP(0, "127.0.0.1")+ skipIfNoICMP(t, err)+ if err != nil {+ t.Fatalf("PingICMP() with a zero timeout must still probe, got %v", err)+ }+ if res.PacketsSent == 0 {+ t.Error("PingICMP() sent no packets with a zero timeout")+ }+ if res.PacketsReceived == 0 {+ t.Errorf("PingICMP() received no replies from loopback: %+v", res)+ }+}diff --git a/apps/checker/cmd/server/main.go b/apps/checker/cmd/server/main.goindex 542486eb9..ed17e4ac1 100644--- a/apps/checker/cmd/server/main.go+++ b/apps/checker/cmd/server/main.go@@ -159,6 +159,12 @@ func main() {ctx, cancel := context.WithCancel(context.Background())defer cancel()+ // Best-effort: allow unprivileged ICMP datagram sockets across all GIDs so+ // PingICMP can avoid the raw-socket fallback. Ignored if not writable.+ if err := os.WriteFile("/proc/sys/net/ipv4/ping_group_range", []byte("0 2147483647"), 0644); err != nil {+ log.Warn().Err(err).Msg("could not widen ping_group_range; icmp will use the raw-socket fallback")+ }+done := make(chan os.Signal, 1)signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)@@ -243,9 +249,11 @@ func main() {router.POST("/checker/http", h.HTTPCheckerHandler)router.POST("/checker/tcp", h.TCPHandler)router.POST("/checker/dns", h.DNSHandler)+ router.POST("/checker/icmp", h.ICMPHandler)router.POST("/ping/:region", h.PingRegionHandler)router.POST("/tcp/:region", h.TCPHandlerRegion)router.POST("/dns/:region", h.DNSHandlerRegion)+ router.POST("/icmp/:region", h.ICMPHandlerRegion)router.GET("/health", func(c *gin.Context) {c.JSON(http.StatusOK, gin.H{"message": "pong", "region": region, "provider": cloudProvider})diff --git a/apps/checker/go.mod b/apps/checker/go.modindex e458e57b4..46ca43051 100644--- a/apps/checker/go.mod+++ b/apps/checker/go.mod@@ -22,6 +22,7 @@ require (go.opentelemetry.io/otel/sdk v1.41.0go.opentelemetry.io/otel/sdk/log v0.17.0go.opentelemetry.io/otel/sdk/metric v1.41.0+ golang.org/x/net v0.51.0google.golang.org/api v0.269.0google.golang.org/protobuf v1.36.11)@@ -72,7 +73,6 @@ require (go.opentelemetry.io/proto/otlp v1.9.0 // indirectgolang.org/x/arch v0.24.0 // indirectgolang.org/x/crypto v0.48.0 // indirect- golang.org/x/net v0.51.0 // indirectgolang.org/x/oauth2 v0.35.0 // indirectgolang.org/x/sync v0.19.0 // indirectgolang.org/x/sys v0.41.0 // indirectdiff --git a/apps/checker/handlers/icmp.go b/apps/checker/handlers/icmp.gonew file mode 100644index 000000000..c50b90daf--- /dev/null+++ b/apps/checker/handlers/icmp.go@@ -0,0 +1,371 @@+package handlers++import (+ "encoding/json"+ "fmt"+ "net/http"+ "strconv"+ "time"++ "github.com/cenkalti/backoff/v4"+ "github.com/gin-gonic/gin"+ "github.com/google/uuid"+ "github.com/openstatushq/openstatus/apps/checker/checker"+ otelOS "github.com/openstatushq/openstatus/apps/checker/pkg/otel"+ "github.com/openstatushq/openstatus/apps/checker/request"+ "github.com/rs/zerolog/log"+)++// Only used for Tinybird.+type ICMPData struct {+ ID string `json:"id"`+ Timing string `json:"timing"`+ ErrorMessage string `json:"errorMessage"`+ Region string `json:"region"`+ Trigger string `json:"trigger"`+ URI string `json:"uri"`+ RequestStatus string `json:"requestStatus,omitempty"`++ RequestId int64 `json:"requestId,omitempty"`+ WorkspaceID int64 `json:"workspaceId"`+ MonitorID int64 `json:"monitorId"`+ Timestamp int64 `json:"timestamp"`+ Latency int64 `json:"latency"`+ LatencyMin int64 `json:"latencyMin"`+ LatencyMax int64 `json:"latencyMax"`+ CronTimestamp int64 `json:"cronTimestamp"`++ PacketsSent uint8 `json:"packetsSent"`+ PacketsReceived uint8 `json:"packetsReceived"`++ Error uint8 `json:"error"`+}++func (h Handler) ICMPHandler(c *gin.Context) {+ ctx := c.Request.Context()+ dataSourceName := "icmp_response__v0"++ if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", h.Secret) {+ c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})++ return+ }++ if h.CloudProvider == "fly" {+ // if the request has been routed to a wrong region, we forward it to the correct one.+ region := c.GetHeader("fly-prefer-region")+ if region != "" && region != h.Region {+ c.Header("fly-replay", fmt.Sprintf("region=%s", region))+ c.String(http.StatusAccepted, "Forwarding request to %s", region)++ return+ }+ }++ var req request.ICMPCheckerRequest+ if err := c.ShouldBindJSON(&req); err != nil {+ log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request")+ c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})++ return+ }++ workspaceId, err := strconv.ParseInt(req.WorkspaceID, 10, 64)+ if err != nil {+ c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})++ return+ }++ monitorId, err := strconv.ParseInt(req.MonitorID, 10, 64)+ if err != nil {+ c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})++ return+ }++ var trigger = "cron"+ if req.Trigger != "" {+ trigger = req.Trigger+ }++ e, f := c.Get("event")+ if f {+ t := e.(map[string]any)+ t["checker"] = map[string]string{+ "uri": req.URI,+ "workspace_id": req.WorkspaceID,+ "monitor_id": req.MonitorID,+ "trigger": trigger,+ "type": "icmp",+ }+ c.Set("event", t)+ }++ var response checker.ICMPResponse++ var retry int+ if req.Retry != 0 {+ retry = int(req.Retry)+ } else {+ retry = 3+ }++ op := func() error {+ res, err := checker.PingICMP(req.Timeout, req.URI)+ if err != nil {+ return fmt.Errorf("unable to check icmp %s", err)+ }++ timingAsString, err := json.Marshal(res.Timing)+ if err != nil {+ return fmt.Errorf("error while parsing timing data %s: %w", req.URI, err)+ }++ latency := res.Latency++ var requestStatus = ""+ switch req.Status {+ case "active":+ requestStatus = "success"+ case "error":+ requestStatus = "error"+ case "degraded":+ requestStatus = "degraded"+ }++ id, err := uuid.NewV7()+ if err != nil {+ return fmt.Errorf("error while generating uuid %w", err)+ }++ timestamp := time.Now().UTC().UnixMilli()++ data := ICMPData{+ ID: id.String(),+ WorkspaceID: workspaceId,+ Timestamp: timestamp,+ Error: 0,+ ErrorMessage: "",+ Region: h.Region,+ MonitorID: monitorId,+ Timing: string(timingAsString),+ Latency: latency,+ LatencyMin: res.LatencyMin,+ LatencyMax: res.LatencyMax,+ PacketsSent: res.PacketsSent,+ PacketsReceived: res.PacketsReceived,+ CronTimestamp: req.CronTimestamp,+ Trigger: trigger,+ URI: req.URI,+ RequestStatus: requestStatus,+ }++ response = checker.ICMPResponse{+ Timestamp: timestamp,+ Timing: res.Timing,+ Latency: latency,+ LatencyMin: res.LatencyMin,+ LatencyMax: res.LatencyMax,+ PacketsSent: res.PacketsSent,+ PacketsReceived: res.PacketsReceived,+ Region: h.Region,+ JobType: "icmp",+ }++ if req.DegradedAfter == 0 && req.Status != "active" {+ checker.UpdateStatus(ctx, checker.UpdateData{+ MonitorId: req.MonitorID,+ Status: "active",+ Region: h.Region,+ CronTimestamp: req.CronTimestamp,+ Latency: latency,+ })+ data.RequestStatus = "success"+ }++ if (req.DegradedAfter > 0 && latency < req.DegradedAfter) && req.Status != "active" {+ checker.UpdateStatus(ctx, checker.UpdateData{+ MonitorId: req.MonitorID,+ Status: "active",+ Region: h.Region,+ CronTimestamp: req.CronTimestamp,+ Latency: latency,+ })+ data.RequestStatus = "success"+ }++ if req.DegradedAfter > 0 && latency > req.DegradedAfter && req.Status != "degraded" {+ checker.UpdateStatus(ctx, checker.UpdateData{+ MonitorId: req.MonitorID,+ Status: "degraded",+ Region: h.Region,+ CronTimestamp: req.CronTimestamp,+ Latency: latency,+ })+ data.RequestStatus = "degraded"+ }++ if err := h.TbClient.SendEvent(ctx, data, dataSourceName); err != nil {+ log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird")+ }++ return nil+ }++ if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), uint64(retry))); err != nil {+ id, e := uuid.NewV7()+ if e != nil {+ log.Ctx(ctx).Error().Err(e).Msg("failed to send event to tinybird")+ return+ }+ data := ICMPData{+ ID: id.String(),+ WorkspaceID: workspaceId,+ CronTimestamp: req.CronTimestamp,+ ErrorMessage: err.Error(),+ Region: h.Region,+ MonitorID: monitorId,+ Error: 1,+ Trigger: trigger,+ URI: req.URI,+ RequestStatus: "error",+ }+ if err := h.TbClient.SendEvent(ctx, data, dataSourceName); err != nil {+ log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird")+ }+ checker.UpdateStatus(ctx, checker.UpdateData{+ MonitorId: req.MonitorID,+ Status: "error",+ Message: err.Error(),+ Region: h.Region,+ CronTimestamp: req.CronTimestamp,+ })++ // Only the success path inside op() fills these in, so a check that+ // exhausted its retries would otherwise be returned under `?data=true`+ // with an empty jobType and region — a shape no caller can parse.+ response.JobType = "icmp"+ response.Region = h.Region+ response.Error = 1+ }++ if req.OtelConfig.Endpoint != "" {+ otelOS.RecordICMPMetrics(ctx, req, response, h.Region)+ }++ returnData := c.Query("data")+ if returnData == "true" {+ c.JSON(http.StatusOK, response)++ return+ }++ c.JSON(http.StatusOK, nil)+}++func (h Handler) ICMPHandlerRegion(c *gin.Context) {+ ctx := c.Request.Context()+ dataSourceName := "check_icmp_response__v0"++ region := c.Param("region")+ if region == "" {+ c.String(http.StatusBadRequest, "region is required")++ return+ }++ if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", h.Secret) {+ c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})++ return+ }++ if h.CloudProvider == "fly" {+ // if the request has been routed to a wrong region, we forward it to the correct one.+ region := c.GetHeader("fly-prefer-region")+ if region != "" && region != h.Region {+ c.Header("fly-replay", fmt.Sprintf("region=%s", region))+ c.String(http.StatusAccepted, "Forwarding request to %s", region)++ return+ }+ }++ var req request.ICMPCheckerRequest+ if err := c.ShouldBindJSON(&req); err != nil {+ log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request")+ c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})++ return+ }++ var response checker.ICMPResponse++ op := func() error {+ timestamp := time.Now().UTC().UnixMilli()+ res, err := checker.PingICMP(req.Timeout, req.URI)+ if err != nil {+ return fmt.Errorf("unable to check icmp %s", err)+ }++ response = checker.ICMPResponse{+ Timestamp: timestamp,+ Timing: res.Timing,+ Latency: res.Latency,+ LatencyMin: res.LatencyMin,+ LatencyMax: res.LatencyMax,+ PacketsSent: res.PacketsSent,+ PacketsReceived: res.PacketsReceived,+ Region: h.Region,+ JobType: "icmp",+ }++ timingAsString, err := json.Marshal(res.Timing)+ if err != nil {+ return fmt.Errorf("error while parsing timing data %s: %w", req.URI, err)+ }++ data := ICMPData{+ CronTimestamp: req.CronTimestamp,+ Timestamp: timestamp,+ Error: 0,+ ErrorMessage: "",+ Region: h.Region,+ Timing: string(timingAsString),+ Latency: res.Latency,+ LatencyMin: res.LatencyMin,+ LatencyMax: res.LatencyMax,+ PacketsSent: res.PacketsSent,+ PacketsReceived: res.PacketsReceived,+ RequestId: req.RequestId,+ Trigger: "api",+ URI: req.URI,+ }++ if req.RequestId != 0 {+ if err := h.TbClient.SendEvent(ctx, data, dataSourceName); err != nil {+ log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird")+ }+ }++ return nil+ }++ err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3))+ if err != nil {+ response.Error = 1+ }++ if req.OtelConfig.Endpoint != "" {+ otelOS.RecordICMPMetrics(ctx, req, response, region)+ }++ if err != nil {+ c.JSON(http.StatusOK, gin.H{"message": "uri not reachable"})++ return+ }++ c.JSON(http.StatusOK, response)+}diff --git a/apps/checker/handlers/icmp_test.go b/apps/checker/handlers/icmp_test.gonew file mode 100644index 000000000..7ba944f85--- /dev/null+++ b/apps/checker/handlers/icmp_test.go@@ -0,0 +1,79 @@+package handlers_test++import (+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/gin-gonic/gin"+ "github.com/openstatushq/openstatus/apps/checker/handlers"+ "github.com/stretchr/testify/assert"+)++func TestICMPHandler_RejectsUnauthorized(t *testing.T) {+ h := handlers.Handler{TbClient: testTinybird(t), Secret: "test", Region: "local"}+ router := gin.New()+ router.POST("/checker/icmp", h.ICMPHandler)++ w := httptest.NewRecorder()+ r, _ := http.NewRequest(http.MethodPost, "/checker/icmp", strings.NewReader(`{"uri":"1.1.1.1"}`))+ r.Header.Set("Authorization", "Basic wrong")+ router.ServeHTTP(w, r)++ assert.Equal(t, http.StatusUnauthorized, w.Code)+}++func TestICMPHandler_RejectsBadPayload(t *testing.T) {+ h := handlers.Handler{TbClient: testTinybird(t), Secret: "test", Region: "local"}+ router := gin.New()+ router.POST("/checker/icmp", h.ICMPHandler)++ w := httptest.NewRecorder()+ r, _ := http.NewRequest(http.MethodPost, "/checker/icmp", strings.NewReader(`{not json`))+ r.Header.Set("Authorization", "Basic test")+ router.ServeHTTP(w, r)++ assert.Equal(t, http.StatusBadRequest, w.Code)+}++func TestICMPHandlerRegion_RequiresRegion(t *testing.T) {+ h := handlers.Handler{TbClient: testTinybird(t), Secret: "test", Region: "local"}+ router := gin.New()+ router.POST("/icmp/:region", h.ICMPHandlerRegion)++ w := httptest.NewRecorder()+ r, _ := http.NewRequest(http.MethodPost, "/icmp/local", strings.NewReader(`{"uri":"1.1.1.1"}`))+ r.Header.Set("Authorization", "Basic wrong")+ router.ServeHTTP(w, r)++ assert.Equal(t, http.StatusUnauthorized, w.Code)+}++// A check that exhausts its retries is still returned under `?data=true`, so it+// has to carry the same identifying fields as a successful one — the success+// path sets them inside op(), which never runs when every attempt fails.+func TestICMPHandler_FailureResponseKeepsJobTypeAndRegion(t *testing.T) {+ h := handlers.Handler{TbClient: testTinybird(t), Secret: "test", Region: "local"}+ router := gin.New()+ router.POST("/checker/icmp", h.ICMPHandler)++ w := httptest.NewRecorder()+ // 192.0.2.1 is TEST-NET-1 (RFC 5737): never answers, so every retry fails.+ body := `{"uri":"192.0.2.1","timeout":200,"retry":1,"workspaceId":"1","monitorId":"1"}`+ r, _ := http.NewRequest(http.MethodPost, "/checker/icmp?data=true", strings.NewReader(body))+ r.Header.Set("Authorization", "Basic test")+ router.ServeHTTP(w, r)++ assert.Equal(t, http.StatusOK, w.Code)++ var res map[string]any+ if err := json.Unmarshal(w.Body.Bytes(), &res); err != nil {+ t.Fatalf("failed to decode response %q: %v", w.Body.String(), err)+ }++ assert.Equal(t, "icmp", res["jobType"], "jobType is the discriminator callers match on")+ assert.Equal(t, "local", res["region"])+ assert.Equal(t, float64(1), res["error"])+}diff --git a/apps/checker/handlers/otel_wiring_test.go b/apps/checker/handlers/otel_wiring_test.goindex 1b913e424..4bbbf03e9 100644--- a/apps/checker/handlers/otel_wiring_test.go+++ b/apps/checker/handlers/otel_wiring_test.go@@ -108,6 +108,35 @@ func TestTCPHandlerRegion_ExportsOTLPOnFailure(t *testing.T) {"expected an OTLP export on TCP failure")}+func TestICMPHandlerRegion_ExportsOTLPOnFailure(t *testing.T) {+ otlp, count := countingOTLPServer(t)++ h := handlers.Handler{+ TbClient: testTinybird(t),+ Secret: "test",+ Region: "local",+ }+ router := gin.New()+ router.POST("/icmp/:region", h.ICMPHandlerRegion)++ req := request.ICMPCheckerRequest{+ URI: "nonexistent-host-openstatus-test.invalid", // resolve failure, no socket needed+ Status: "active",+ Timeout: 1000,+ }+ req.OtelConfig.Endpoint = otlp.URL+ body, _ := json.Marshal(req)++ w := httptest.NewRecorder()+ r, _ := http.NewRequest(http.MethodPost, "/icmp/local", strings.NewReader(string(body)))+ r.Header.Set("Authorization", "Basic test")+ router.ServeHTTP(w, r)++ assert.Equal(t, http.StatusOK, w.Code)+ assert.Eventually(t, func() bool { return atomic.LoadInt64(count) > 0 }, 10*time.Second, 50*time.Millisecond,+ "expected an OTLP export on ICMP failure")+}+func TestDNSHandler_ExportsOTLPOnFailure(t *testing.T) {otlp, count := countingOTLPServer(t)diff --git a/apps/checker/pkg/job/icmp_job.go b/apps/checker/pkg/job/icmp_job.gonew file mode 100644index 000000000..0cbce60fb--- /dev/null+++ b/apps/checker/pkg/job/icmp_job.go@@ -0,0 +1,163 @@+package job++import (+ "context"+ "encoding/json"+ "fmt"+ "time"++ "github.com/cenkalti/backoff/v5"+ "github.com/google/uuid"+ "github.com/openstatushq/openstatus/apps/checker/checker"+ "github.com/openstatushq/openstatus/apps/checker/pkg/otel"+ v1 "github.com/openstatushq/openstatus/apps/checker/proto/private_location/v1"+ "github.com/openstatushq/openstatus/apps/checker/request"+)++// ICMPPrivateRegionData represents the result of an ICMP monitor check+type ICMPPrivateRegionData struct {+ ID string `json:"id"`+ URI string `json:"uri"`+ RequestStatus string `json:"request_status"`+ Message string `json:"message"`+ Latency int64 `json:"latency"`+ LatencyMin int64 `json:"latency_min"`+ LatencyMax int64 `json:"latency_max"`+ PacketsSent int64 `json:"packets_sent"`+ PacketsReceived int64 `json:"packets_received"`+ Timestamp int64 `json:"timestamp"`+ CronTimestamp int64 `json:"cron_timestamp"`+ Error int `json:"error"`+ Timing string `json:"timing"`+}++func (jobRunner) ICMPJob(ctx context.Context, monitor *v1.ICMPMonitor, region string) (*ICMPPrivateRegionData, error) {+ retry := monitor.Retry+ if retry == 0 {+ retry = 3+ }++ var degradedAfter int64+ if monitor.DegradedAt != nil {+ degradedAfter = *monitor.DegradedAt+ }++ req := icmpCheckerRequest(monitor)++ var called int+ var lastResult checker.ICMPResponse++ op := func() (*ICMPPrivateRegionData, error) {+ called+++ start := time.Now().UTC().UnixMilli()+ res, err := checker.PingICMP(monitor.Timeout, monitor.Uri)+ if err != nil {+ if called < int(retry) {+ return nil, fmt.Errorf("ICMP check failed: %w", err)+ }++ data, dataErr := newICMPData(monitor.Uri, start)+ if dataErr != nil {+ return nil, dataErr+ }++ lastResult = checker.ICMPResponse{Error: 1}++ data.RequestStatus = "error"+ data.Error = 1+ data.Message = err.Error()++ return data, nil+ }++ lastResult = checker.ICMPResponse{+ Latency: res.Latency,+ LatencyMin: res.LatencyMin,+ LatencyMax: res.LatencyMax,+ PacketsSent: res.PacketsSent,+ PacketsReceived: res.PacketsReceived,+ Timing: res.Timing,+ }++ // "success", not "active": the Tinybird ICMP status and uptime pipes+ // count `requestStatus = 'success'`, and the HTTP/TCP/DNS jobs all+ // report it that way.+ var requestStatus = "success"+ if degradedAfter > 0 && res.Latency > degradedAfter {+ requestStatus = "degraded"+ }++ data, err := newICMPData(monitor.Uri, start)+ if err != nil {+ return nil, err+ }++ timingAsString, err := json.Marshal(res.Timing)+ if err != nil {+ return nil, fmt.Errorf("error while parsing timing data %s: %w", monitor.Uri, err)+ }++ data.Latency = res.Latency+ data.LatencyMin = res.LatencyMin+ data.LatencyMax = res.LatencyMax+ data.PacketsSent = int64(res.PacketsSent)+ data.PacketsReceived = int64(res.PacketsReceived)+ data.RequestStatus = requestStatus+ data.Error = 0+ data.Message = fmt.Sprintf("Successfully pinged %s", monitor.Uri)+ data.Timing = string(timingAsString)++ return data, nil+ }++ resp, err := backoff.Retry(ctx, op,+ backoff.WithMaxTries(uint(retry)),+ backoff.WithBackOff(backoff.NewExponentialBackOff()),+ )++ recordICMPOtel(ctx, req, lastResult, region, err != nil)++ if err != nil {+ return nil, fmt.Errorf("ICMP job failed after %d retries: %w", retry, err)+ }+ return resp, nil+}++// newICMPData stamps the fields every result must carry regardless of outcome.+// `Timestamp`/`CronTimestamp` are required: ValidateIngestICMPRequest rejects a+// non-positive timestamp, so a result missing them is dropped at ingest.+func newICMPData(uri string, start int64) (*ICMPPrivateRegionData, error) {+ id, err := uuid.NewV7()+ if err != nil {+ return nil, fmt.Errorf("failed to generate UUID: %w", err)+ }++ return &ICMPPrivateRegionData{+ ID: id.String(),+ URI: uri,+ Timestamp: start,+ CronTimestamp: start,+ }, nil+}++func icmpCheckerRequest(monitor *v1.ICMPMonitor) request.ICMPCheckerRequest {+ req := request.ICMPCheckerRequest{URI: monitor.Uri}+ if otelCfg := monitor.GetOtelConfig(); otelCfg.GetEndpoint() != "" {+ req.OtelConfig.Endpoint = otelCfg.GetEndpoint()+ req.OtelConfig.Headers = headersToMap(otelCfg.GetHeaders())+ }++ return req+}++func recordICMPOtel(ctx context.Context, req request.ICMPCheckerRequest, result checker.ICMPResponse, region string, failed bool) {+ if req.OtelConfig.Endpoint == "" {+ return+ }++ if failed {+ result.Error = 1+ }++ otel.RecordICMPMetrics(ctx, req, result, region)+}diff --git a/apps/checker/pkg/job/icmp_job_test.go b/apps/checker/pkg/job/icmp_job_test.gonew file mode 100644index 000000000..114a0dac2--- /dev/null+++ b/apps/checker/pkg/job/icmp_job_test.go@@ -0,0 +1,126 @@+package job_test++import (+ "context"+ "strings"+ "testing"+ "time"++ "github.com/openstatushq/openstatus/apps/checker/pkg/job"+ v1 "github.com/openstatushq/openstatus/apps/checker/proto/private_location/v1"+)++func TestICMPJob_Success(t *testing.T) {+ monitor := &v1.ICMPMonitor{+ Uri: "127.0.0.1",+ Timeout: 2000,+ Retry: 1,+ }+ data, err := job.NewJobRunner().ICMPJob(context.Background(), monitor, "test-region")+ if err != nil {+ t.Fatalf("expected no error, got %v", err)+ }+ // unprivileged Linux CI (no ping_group_range) can't open the socket+ if data.RequestStatus == "error" && strings.Contains(data.Message, "icmp socket error") {+ t.Skipf("icmp sockets unavailable in this environment: %s", data.Message)+ }+ if data.RequestStatus != "success" {+ t.Errorf("expected RequestStatus 'success', got '%s'", data.RequestStatus)+ }+ if data.Error != 0 {+ t.Errorf("expected Error 0, got %d", data.Error)+ }+ if data.PacketsReceived == 0 {+ t.Errorf("expected at least one packet received, got %d", data.PacketsReceived)+ }+}++func TestICMPJob_Failure(t *testing.T) {+ // 192.0.2.1 is TEST-NET-1 (RFC 5737): never answers.+ monitor := &v1.ICMPMonitor{+ Uri: "192.0.2.1",+ Timeout: 1000,+ Retry: 1,+ }+ data, err := job.NewJobRunner().ICMPJob(context.Background(), monitor, "test-region")+ if err != nil {+ t.Fatalf("expected no error, got %v", err)+ }+ if data.RequestStatus != "error" {+ t.Errorf("expected RequestStatus 'error', got '%s'", data.RequestStatus)+ }+ if data.Error != 1 {+ t.Errorf("expected Error 1, got %d", data.Error)+ }+}++// The private-location server rejects an ingest whose timestamp is not strictly+// positive (ValidateIngestICMPRequest), and the scheduler does not retry a+// rejected ingest — so a result without timestamps is silently dropped.+func TestICMPJob_StampsTimestamps(t *testing.T) {+ before := time.Now().UTC().UnixMilli()++ for _, tc := range []struct {+ name string+ uri string+ }{+ {name: "success", uri: "127.0.0.1"},+ // 192.0.2.1 is TEST-NET-1 (RFC 5737): never answers.+ {name: "failure", uri: "192.0.2.1"},+ } {+ t.Run(tc.name, func(t *testing.T) {+ monitor := &v1.ICMPMonitor{Uri: tc.uri, Timeout: 1000, Retry: 1}+ data, err := job.NewJobRunner().ICMPJob(context.Background(), monitor, "test-region")+ if err != nil {+ t.Fatalf("expected no error, got %v", err)+ }+ if data.RequestStatus == "error" && strings.Contains(data.Message, "icmp socket error") {+ t.Skipf("icmp sockets unavailable in this environment: %s", data.Message)+ }++ after := time.Now().UTC().UnixMilli()++ if data.Timestamp <= 0 {+ t.Errorf("Timestamp must be positive or the ingest is rejected, got %d", data.Timestamp)+ }+ if data.CronTimestamp <= 0 {+ t.Errorf("CronTimestamp must be positive, got %d", data.CronTimestamp)+ }+ if data.Timestamp < before || data.Timestamp > after {+ t.Errorf("Timestamp %d outside the run window [%d, %d]", data.Timestamp, before, after)+ }+ if data.ID == "" {+ t.Error("ID must be set")+ }+ if data.URI != tc.uri {+ t.Errorf("URI = %q, want %q", data.URI, tc.uri)+ }+ })+ }+}++// The Tinybird ICMP aggregations bucket on the literal string — see+// aggregate__icmp_status_45d__v0.pipe and the icmp_uptime_* endpoints, which+// count `requestStatus = 'success'`. A healthy check reported under any other+// label is ingested but invisible to uptime and status.+func TestICMPJob_SuccessUsesTinybirdStatusVocabulary(t *testing.T) {+ monitor := &v1.ICMPMonitor{Uri: "127.0.0.1", Timeout: 2000, Retry: 1}+ data, err := job.NewJobRunner().ICMPJob(context.Background(), monitor, "test-region")+ if err != nil {+ t.Fatalf("expected no error, got %v", err)+ }+ if data.RequestStatus == "error" && strings.Contains(data.Message, "icmp socket error") {+ t.Skipf("icmp sockets unavailable in this environment: %s", data.Message)+ }++ // The full vocabulary the pipes recognise; "active" is not part of it.+ switch data.RequestStatus {+ case "success", "degraded", "error":+ default:+ t.Errorf("RequestStatus %q is not counted by the Tinybird ICMP pipes", data.RequestStatus)+ }++ if data.RequestStatus != "success" {+ t.Errorf("a healthy ping must report \"success\", got %q", data.RequestStatus)+ }+}diff --git a/apps/checker/pkg/job/job.go b/apps/checker/pkg/job/job.goindex 944e4de0b..74518d410 100644--- a/apps/checker/pkg/job/job.go+++ b/apps/checker/pkg/job/job.go@@ -31,6 +31,7 @@ type JobRunner interface {TCPJob(ctx context.Context, monitor *v1.TCPMonitor, region string) (*TCPPrivateRegionData, error)HTTPJob(ctx context.Context, monitor *v1.HTTPMonitor, region string) (*HttpPrivateRegionData, error)DNSJob(ctx context.Context, monitor *v1.DNSMonitor) (*DNSPrivateRegionData, error)+ ICMPJob(ctx context.Context, monitor *v1.ICMPMonitor, region string) (*ICMPPrivateRegionData, error)}type jobRunner struct{}diff --git a/apps/checker/pkg/otel/otel.go b/apps/checker/pkg/otel/otel.goindex 51f83a0b1..c4938d364 100644--- a/apps/checker/pkg/otel/otel.go+++ b/apps/checker/pkg/otel/otel.go@@ -80,10 +80,25 @@ func withMeter(ctx context.Context, endpoint string, headers map[string]string,fn(otel.Meter("OpenStatus"))}-// recordGauge creates a Float64Gauge and records a value.+// UCUM unit codes, as OpenTelemetry expects them.+const (+ unitMilliseconds = "ms"+ unitPercent = "%"+)++// recordGauge creates a Float64Gauge for a duration in milliseconds and records+// a value. Use recordGaugeWithUnit for anything that is not a duration —+// backends render a gauge according to its unit, so a mislabelled one is read+// as a time span.func recordGauge(ctx context.Context, meter metric.Meter, name, description string, value float64, att metric.MeasurementOption) error {+ return recordGaugeWithUnit(ctx, meter, name, description, unitMilliseconds, value, att)+}++// recordGaugeWithUnit creates a Float64Gauge carrying an explicit unit and+// records a value.+func recordGaugeWithUnit(ctx context.Context, meter metric.Meter, name, description, unit string, value float64, att metric.MeasurementOption) error {gauge, err := meter.Float64Gauge(name,- metric.WithDescription(description), metric.WithUnit("ms"))+ metric.WithDescription(description), metric.WithUnit(unit))if err != nil {return err}@@ -169,6 +184,37 @@ func RecordDNSMetrics(ctx context.Context, req request.DNSCheckerRequest, latenc})}+func RecordICMPMetrics(ctx context.Context, req request.ICMPCheckerRequest, result checker.ICMPResponse, region string) {+ withMeter(ctx, req.OtelConfig.Endpoint, req.OtelConfig.Headers, func(meter metric.Meter) {+ att := metric.WithAttributes(+ attribute.String("openstatus.probes", region),+ attribute.String("openstatus.target", req.URI),+ )+ recordICMPInstruments(ctx, meter, result, att)+ })+}++// recordICMPInstruments is split out of RecordICMPMetrics so tests can supply a+// collectable meter: withMeter installs a real OTLP provider globally, which+// leaves nothing to assert against.+func recordICMPInstruments(ctx context.Context, meter metric.Meter, result checker.ICMPResponse, att metric.MeasurementOption) {+ if result.Error == 1 {+ recordErrorCounter(ctx, meter, att)+ return+ }++ recordStatusCounter(ctx, meter, att)++ if err := recordGauge(ctx, meter, "openstatus.icmp.request.duration", "Duration of the check", float64(result.Latency), att); err != nil {+ log.Ctx(ctx).Error().Err(err).Str("metric", "openstatus.icmp.request.duration").Msg("Error creating gauge")+ }++ packetLoss := float64(result.PacketsSent-result.PacketsReceived) / float64(result.PacketsSent) * 100+ if err := recordGaugeWithUnit(ctx, meter, "openstatus.icmp.packet.loss", "Packet loss percentage", unitPercent, packetLoss, att); err != nil {+ log.Ctx(ctx).Error().Err(err).Str("metric", "openstatus.icmp.packet.loss").Msg("Error creating gauge")+ }+}+func RecordTCPMetrics(ctx context.Context, req request.TCPCheckerRequest, result checker.TCPResponse, region string) {withMeter(ctx, req.OtelConfig.Endpoint, req.OtelConfig.Headers, func(meter metric.Meter) {att := metric.WithAttributes(diff --git a/apps/checker/pkg/otel/otel_test.go b/apps/checker/pkg/otel/otel_test.goindex 628e46f57..c34281194 100644--- a/apps/checker/pkg/otel/otel_test.go+++ b/apps/checker/pkg/otel/otel_test.go@@ -74,6 +74,70 @@ func TestRecordGauge(t *testing.T) {assert.Equal(t, "test-value", val.AsString())}+func TestRecordGaugeWithUnit(t *testing.T) {+ for _, tc := range []struct {+ name string+ unit string+ }{+ {name: "percentage", unit: unitPercent},+ {name: "duration", unit: unitMilliseconds},+ {name: "unitless", unit: ""},+ } {+ t.Run(tc.name, func(t *testing.T) {+ meter, reader := newTestMeter(t)+ att := metric.WithAttributes(attribute.String("region", "ams"))++ err := recordGaugeWithUnit(context.Background(), meter, "test.gauge", "A test gauge", tc.unit, 12.5, att)+ require.NoError(t, err)++ rm := collectMetrics(t, reader)+ require.Len(t, rm.ScopeMetrics, 1)+ require.Len(t, rm.ScopeMetrics[0].Metrics, 1)++ m := rm.ScopeMetrics[0].Metrics[0]+ assert.Equal(t, tc.unit, m.Unit)++ gauge, ok := m.Data.(metricdata.Gauge[float64])+ require.True(t, ok)+ require.Len(t, gauge.DataPoints, 1)+ assert.Equal(t, 12.5, gauge.DataPoints[0].Value)+ })+ }+}++// The two ICMP gauges carry different units, so they cannot share the+// ms-defaulting helper: a percentage exported as "ms" is rendered as a duration+// by the backend.+func TestICMPGaugeUnits(t *testing.T) {+ meter, reader := newTestMeter(t)+ att := metric.WithAttributes(attribute.String("openstatus.probes", "ams"))++ recordICMPInstruments(context.Background(), meter, checker.ICMPResponse{+ Latency: 42,+ PacketsSent: 3,+ PacketsReceived: 2,+ }, att)++ units := map[string]string{}+ values := map[string]float64{}+ for _, sm := range collectMetrics(t, reader).ScopeMetrics {+ for _, m := range sm.Metrics {+ units[m.Name] = m.Unit+ if gauge, ok := m.Data.(metricdata.Gauge[float64]); ok && len(gauge.DataPoints) == 1 {+ values[m.Name] = gauge.DataPoints[0].Value+ }+ }+ }++ assert.Equal(t, "ms", units["openstatus.icmp.request.duration"])+ assert.Equal(t, "%", units["openstatus.icmp.packet.loss"],+ "packet loss is a percentage, not a duration")++ assert.Equal(t, float64(42), values["openstatus.icmp.request.duration"])+ assert.InDelta(t, 33.33, values["openstatus.icmp.packet.loss"], 0.01,+ "1 of 3 packets lost is ~33%, confirming the value really is a percentage")+}+func TestRecordGauge_MultipleMetrics(t *testing.T) {meter, reader := newTestMeter(t)ctx := context.Background()diff --git a/apps/checker/pkg/scheduler/scheduler.go b/apps/checker/pkg/scheduler/scheduler.goindex 6a12834c8..87cab525f 100644--- a/apps/checker/pkg/scheduler/scheduler.go+++ b/apps/checker/pkg/scheduler/scheduler.go@@ -243,6 +243,61 @@ func (mm *MonitorManager) UpdateMonitors(ctx context.Context) {log.Printf("Started DNS monitoring job for %s (%s)", m.Id, m.Uri)}+ for _, m := range res.Msg.IcmpMonitors {+ currentIDs[m.Id] = struct{}{}+ if mm.shouldSchedule(m.Id, m) {++ interval := time.Duration(intervalToSecond(m.Periodicity)) * time.Second+ task := tasks.Task{+ Interval: interval,+ RunOnce: false,+ RunSingleInstance: true,+ FuncWithTaskContext: func(ctx tasks.TaskContext) error {++ monitor := m+ c := context.Background()+ log.Printf("Starting ICMP job for monitor %s (%s)", monitor.Id, monitor.Uri)+ data, err := mm.JobRunner.ICMPJob(c, monitor, res.Msg.Region)+ if err != nil {+ log.Printf("ICMP monitor check failed for %s (%s): %v", monitor.Id, monitor.Uri, err)+ return err+ }+ resp, ingestErr := mm.Client.IngestICMP(c, &connect.Request[v1.IngestICMPRequest]{+ Msg: &v1.IngestICMPRequest{+ MonitorId: monitor.Id,+ Id: data.ID,+ Uri: monitor.Uri,+ Message: data.Message,+ Latency: data.Latency,+ LatencyMin: data.LatencyMin,+ LatencyMax: data.LatencyMax,+ PacketsSent: data.PacketsSent,+ PacketsReceived: data.PacketsReceived,+ RequestStatus: data.RequestStatus,+ Error: int64(data.Error),+ CronTimestamp: data.CronTimestamp,+ Timestamp: data.Timestamp,+ Timing: data.Timing,+ },+ })+ if ingestErr != nil {+ log.Printf("Failed to ingest ICMP result for %s (%s): %v", monitor.Id, monitor.Uri, ingestErr)+ return ingestErr+ }+ log.Printf("ICMP monitor check succeeded for %s (%s), ingest response: %v", monitor.Id, monitor.Uri, resp)++ return nil+ },+ }+ err := mm.Scheduler.AddWithID(m.Id, &task)+ if err != nil {+ log.Printf("Failed to add ICMP monitor job for %s (%s): %v", m.Id, m.Uri, err)+ continue+ }+ log.Printf("Started ICMP monitoring job for %s (%s)", m.Id, m.Uri)+ }+ }+mm.mu.Lock()for id := range mm.Scheduler.Tasks() {if _, stillExists := currentIDs[id]; !stillExists {diff --git a/apps/checker/pkg/scheduler/scheduler_test.go b/apps/checker/pkg/scheduler/scheduler_test.goindex 455144563..ba1013a57 100644--- a/apps/checker/pkg/scheduler/scheduler_test.go+++ b/apps/checker/pkg/scheduler/scheduler_test.go@@ -74,12 +74,17 @@ func (m *mockJobRunner) DNSJob(ctx context.Context, monitor *v1.DNSMonitor) (*jo}, nil}+func (m *mockJobRunner) ICMPJob(ctx context.Context, monitor *v1.ICMPMonitor, region string) (*job.ICMPPrivateRegionData, error) {+ return &job.ICMPPrivateRegionData{}, nil+}+// mockClient implements v1.PrivateLocationServiceClient for testingtype mockClient struct {MonitorsFunc func(ctx context.Context, req *connect.Request[v1.MonitorsRequest]) (*connect.Response[v1.MonitorsResponse], error)IngestHTTPFunc func(ctx context.Context, req *connect.Request[v1.IngestHTTPRequest]) (*connect.Response[v1.IngestHTTPResponse], error)IngestTCPFunc func(ctx context.Context, req *connect.Request[v1.IngestTCPRequest]) (*connect.Response[v1.IngestTCPResponse], error)IngestDNSFunc func(ctx context.Context, req *connect.Request[v1.IngestDNSRequest]) (*connect.Response[v1.IngestDNSResponse], error)+ IngestICMPFunc func(ctx context.Context, req *connect.Request[v1.IngestICMPRequest]) (*connect.Response[v1.IngestICMPResponse], error)}func (m *mockClient) Monitors(ctx context.Context, req *connect.Request[v1.MonitorsRequest]) (*connect.Response[v1.MonitorsResponse], error) {@@ -94,6 +99,9 @@ func (m *mockClient) IngestTCP(ctx context.Context, req *connect.Request[v1.Ingefunc (m *mockClient) IngestDNS(ctx context.Context, req *connect.Request[v1.IngestDNSRequest]) (*connect.Response[v1.IngestDNSResponse], error) {return m.IngestDNSFunc(ctx, req)}+func (m *mockClient) IngestICMP(ctx context.Context, req *connect.Request[v1.IngestICMPRequest]) (*connect.Response[v1.IngestICMPResponse], error) {+ return m.IngestICMPFunc(ctx, req)+}func TestMonitorManager_StartAndStopJobs_WithJobRunner(t *testing.T) {ctx := t.Context()diff --git a/apps/checker/proto/private_location/v1/icmp_monitor.pb.go b/apps/checker/proto/private_location/v1/icmp_monitor.pb.gonew file mode 100644index 000000000..d842fba5e--- /dev/null+++ b/apps/checker/proto/private_location/v1/icmp_monitor.pb.go@@ -0,0 +1,183 @@+// Code generated by protoc-gen-go. DO NOT EDIT.+// versions:+// protoc-gen-go v1.36.11+// protoc (unknown)+// source: private_location/v1/icmp_monitor.proto++package v1++import (+ protoreflect "google.golang.org/protobuf/reflect/protoreflect"+ protoimpl "google.golang.org/protobuf/runtime/protoimpl"+ reflect "reflect"+ sync "sync"+ unsafe "unsafe"+)++const (+ // Verify that this generated code is sufficiently up-to-date.+ _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)+ // Verify that runtime/protoimpl is sufficiently up-to-date.+ _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)+)++type ICMPMonitor struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`+ Uri string `protobuf:"bytes,2,opt,name=uri,proto3" json:"uri,omitempty"`+ Timeout int64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`+ DegradedAt *int64 `protobuf:"varint,4,opt,name=degraded_at,json=degradedAt,proto3,oneof" json:"degraded_at,omitempty"`+ Periodicity string `protobuf:"bytes,5,opt,name=periodicity,proto3" json:"periodicity,omitempty"`+ Retry int64 `protobuf:"varint,6,opt,name=retry,proto3" json:"retry,omitempty"`+ OtelConfig *OtelConfig `protobuf:"bytes,20,opt,name=otel_config,json=otelConfig,proto3" json:"otel_config,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *ICMPMonitor) Reset() {+ *x = ICMPMonitor{}+ mi := &file_private_location_v1_icmp_monitor_proto_msgTypes[0]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *ICMPMonitor) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*ICMPMonitor) ProtoMessage() {}++func (x *ICMPMonitor) ProtoReflect() protoreflect.Message {+ mi := &file_private_location_v1_icmp_monitor_proto_msgTypes[0]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use ICMPMonitor.ProtoReflect.Descriptor instead.+func (*ICMPMonitor) Descriptor() ([]byte, []int) {+ return file_private_location_v1_icmp_monitor_proto_rawDescGZIP(), []int{0}+}++func (x *ICMPMonitor) GetId() string {+ if x != nil {+ return x.Id+ }+ return ""+}++func (x *ICMPMonitor) GetUri() string {+ if x != nil {+ return x.Uri+ }+ return ""+}++func (x *ICMPMonitor) GetTimeout() int64 {+ if x != nil {+ return x.Timeout+ }+ return 0+}++func (x *ICMPMonitor) GetDegradedAt() int64 {+ if x != nil && x.DegradedAt != nil {+ return *x.DegradedAt+ }+ return 0+}++func (x *ICMPMonitor) GetPeriodicity() string {+ if x != nil {+ return x.Periodicity+ }+ return ""+}++func (x *ICMPMonitor) GetRetry() int64 {+ if x != nil {+ return x.Retry+ }+ return 0+}++func (x *ICMPMonitor) GetOtelConfig() *OtelConfig {+ if x != nil {+ return x.OtelConfig+ }+ return nil+}++var File_private_location_v1_icmp_monitor_proto protoreflect.FileDescriptor++const file_private_location_v1_icmp_monitor_proto_rawDesc = "" ++ "\n" ++ "&private_location/v1/icmp_monitor.proto\x12\x13private_location.v1\x1a\x1eprivate_location/v1/otel.proto\"\xf9\x01\n" ++ "\vICMPMonitor\x12\x0e\n" ++ "\x02id\x18\x01 \x01(\tR\x02id\x12\x10\n" ++ "\x03uri\x18\x02 \x01(\tR\x03uri\x12\x18\n" ++ "\atimeout\x18\x03 \x01(\x03R\atimeout\x12$\n" ++ "\vdegraded_at\x18\x04 \x01(\x03H\x00R\n" ++ "degradedAt\x88\x01\x01\x12 \n" ++ "\vperiodicity\x18\x05 \x01(\tR\vperiodicity\x12\x14\n" ++ "\x05retry\x18\x06 \x01(\x03R\x05retry\x12@\n" ++ "\votel_config\x18\x14 \x01(\v2\x1f.private_location.v1.OtelConfigR\n" ++ "otelConfigB\x0e\n" ++ "\f_degraded_atBJZHgithub.com/openstatushq/openstatus/packages/proto/private_location/v1;v1b\x06proto3"++var (+ file_private_location_v1_icmp_monitor_proto_rawDescOnce sync.Once+ file_private_location_v1_icmp_monitor_proto_rawDescData []byte+)++func file_private_location_v1_icmp_monitor_proto_rawDescGZIP() []byte {+ file_private_location_v1_icmp_monitor_proto_rawDescOnce.Do(func() {+ file_private_location_v1_icmp_monitor_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_private_location_v1_icmp_monitor_proto_rawDesc), len(file_private_location_v1_icmp_monitor_proto_rawDesc)))+ })+ return file_private_location_v1_icmp_monitor_proto_rawDescData+}++var file_private_location_v1_icmp_monitor_proto_msgTypes = make([]protoimpl.MessageInfo, 1)+var file_private_location_v1_icmp_monitor_proto_goTypes = []any{+ (*ICMPMonitor)(nil), // 0: private_location.v1.ICMPMonitor+ (*OtelConfig)(nil), // 1: private_location.v1.OtelConfig+}+var file_private_location_v1_icmp_monitor_proto_depIdxs = []int32{+ 1, // 0: private_location.v1.ICMPMonitor.otel_config:type_name -> private_location.v1.OtelConfig+ 1, // [1:1] is the sub-list for method output_type+ 1, // [1:1] is the sub-list for method input_type+ 1, // [1:1] is the sub-list for extension type_name+ 1, // [1:1] is the sub-list for extension extendee+ 0, // [0:1] is the sub-list for field type_name+}++func init() { file_private_location_v1_icmp_monitor_proto_init() }+func file_private_location_v1_icmp_monitor_proto_init() {+ if File_private_location_v1_icmp_monitor_proto != nil {+ return+ }+ file_private_location_v1_otel_proto_init()+ file_private_location_v1_icmp_monitor_proto_msgTypes[0].OneofWrappers = []any{}+ type x struct{}+ out := protoimpl.TypeBuilder{+ File: protoimpl.DescBuilder{+ GoPackagePath: reflect.TypeOf(x{}).PkgPath(),+ RawDescriptor: unsafe.Slice(unsafe.StringData(file_private_location_v1_icmp_monitor_proto_rawDesc), len(file_private_location_v1_icmp_monitor_proto_rawDesc)),+ NumEnums: 0,+ NumMessages: 1,+ NumExtensions: 0,+ NumServices: 0,+ },+ GoTypes: file_private_location_v1_icmp_monitor_proto_goTypes,+ DependencyIndexes: file_private_location_v1_icmp_monitor_proto_depIdxs,+ MessageInfos: file_private_location_v1_icmp_monitor_proto_msgTypes,+ }.Build()+ File_private_location_v1_icmp_monitor_proto = out.File+ file_private_location_v1_icmp_monitor_proto_goTypes = nil+ file_private_location_v1_icmp_monitor_proto_depIdxs = nil+}diff --git a/apps/checker/proto/private_location/v1/private_location.connect.go b/apps/checker/proto/private_location/v1/private_location.connect.goindex 40235485f..8138ab7c5 100644--- a/apps/checker/proto/private_location/v1/private_location.connect.go+++ b/apps/checker/proto/private_location/v1/private_location.connect.go@@ -44,6 +44,9 @@ const (// PrivateLocationServiceIngestDNSProcedure is the fully-qualified name of the// PrivateLocationService's IngestDNS RPC.PrivateLocationServiceIngestDNSProcedure = "/private_location.v1.PrivateLocationService/IngestDNS"+ // PrivateLocationServiceIngestICMPProcedure is the fully-qualified name of the+ // PrivateLocationService's IngestICMP RPC.+ PrivateLocationServiceIngestICMPProcedure = "/private_location.v1.PrivateLocationService/IngestICMP")// PrivateLocationServiceClient is a client for the private_location.v1.PrivateLocationService@@ -53,6 +56,7 @@ type PrivateLocationServiceClient interface {IngestTCP(context.Context, *connect.Request[IngestTCPRequest]) (*connect.Response[IngestTCPResponse], error)IngestHTTP(context.Context, *connect.Request[IngestHTTPRequest]) (*connect.Response[IngestHTTPResponse], error)IngestDNS(context.Context, *connect.Request[IngestDNSRequest]) (*connect.Response[IngestDNSResponse], error)+ IngestICMP(context.Context, *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error)}// NewPrivateLocationServiceClient constructs a client for the@@ -90,6 +94,12 @@ func NewPrivateLocationServiceClient(httpClient connect.HTTPClient, baseURL striconnect.WithSchema(privateLocationServiceMethods.ByName("IngestDNS")),connect.WithClientOptions(opts...),),+ ingestICMP: connect.NewClient[IngestICMPRequest, IngestICMPResponse](+ httpClient,+ baseURL+PrivateLocationServiceIngestICMPProcedure,+ connect.WithSchema(privateLocationServiceMethods.ByName("IngestICMP")),+ connect.WithClientOptions(opts...),+ ),}}@@ -99,6 +109,7 @@ type privateLocationServiceClient struct {ingestTCP *connect.Client[IngestTCPRequest, IngestTCPResponse]ingestHTTP *connect.Client[IngestHTTPRequest, IngestHTTPResponse]ingestDNS *connect.Client[IngestDNSRequest, IngestDNSResponse]+ ingestICMP *connect.Client[IngestICMPRequest, IngestICMPResponse]}// Monitors calls private_location.v1.PrivateLocationService.Monitors.@@ -121,6 +132,11 @@ func (c *privateLocationServiceClient) IngestDNS(ctx context.Context, req *connereturn c.ingestDNS.CallUnary(ctx, req)}+// IngestICMP calls private_location.v1.PrivateLocationService.IngestICMP.+func (c *privateLocationServiceClient) IngestICMP(ctx context.Context, req *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error) {+ return c.ingestICMP.CallUnary(ctx, req)+}+// PrivateLocationServiceHandler is an implementation of the// private_location.v1.PrivateLocationService service.type PrivateLocationServiceHandler interface {@@ -128,6 +144,7 @@ type PrivateLocationServiceHandler interface {IngestTCP(context.Context, *connect.Request[IngestTCPRequest]) (*connect.Response[IngestTCPResponse], error)IngestHTTP(context.Context, *connect.Request[IngestHTTPRequest]) (*connect.Response[IngestHTTPResponse], error)IngestDNS(context.Context, *connect.Request[IngestDNSRequest]) (*connect.Response[IngestDNSResponse], error)+ IngestICMP(context.Context, *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error)}// NewPrivateLocationServiceHandler builds an HTTP handler from the service implementation. It@@ -161,6 +178,12 @@ func NewPrivateLocationServiceHandler(svc PrivateLocationServiceHandler, opts ..connect.WithSchema(privateLocationServiceMethods.ByName("IngestDNS")),connect.WithHandlerOptions(opts...),)+ privateLocationServiceIngestICMPHandler := connect.NewUnaryHandler(+ PrivateLocationServiceIngestICMPProcedure,+ svc.IngestICMP,+ connect.WithSchema(privateLocationServiceMethods.ByName("IngestICMP")),+ connect.WithHandlerOptions(opts...),+ )return "/private_location.v1.PrivateLocationService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {switch r.URL.Path {case PrivateLocationServiceMonitorsProcedure:@@ -171,6 +194,8 @@ func NewPrivateLocationServiceHandler(svc PrivateLocationServiceHandler, opts ..privateLocationServiceIngestHTTPHandler.ServeHTTP(w, r)case PrivateLocationServiceIngestDNSProcedure:privateLocationServiceIngestDNSHandler.ServeHTTP(w, r)+ case PrivateLocationServiceIngestICMPProcedure:+ privateLocationServiceIngestICMPHandler.ServeHTTP(w, r)default:http.NotFound(w, r)}@@ -195,3 +220,7 @@ func (UnimplementedPrivateLocationServiceHandler) IngestHTTP(context.Context, *cfunc (UnimplementedPrivateLocationServiceHandler) IngestDNS(context.Context, *connect.Request[IngestDNSRequest]) (*connect.Response[IngestDNSResponse], error) {return nil, connect.NewError(connect.CodeUnimplemented, errors.New("private_location.v1.PrivateLocationService.IngestDNS is not implemented"))}++func (UnimplementedPrivateLocationServiceHandler) IngestICMP(context.Context, *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error) {+ return nil, connect.NewError(connect.CodeUnimplemented, errors.New("private_location.v1.PrivateLocationService.IngestICMP is not implemented"))+}diff --git a/apps/checker/proto/private_location/v1/private_location.pb.go b/apps/checker/proto/private_location/v1/private_location.pb.goindex e31eb986c..a28112bc7 100644--- a/apps/checker/proto/private_location/v1/private_location.pb.go+++ b/apps/checker/proto/private_location/v1/private_location.pb.go@@ -62,6 +62,7 @@ type MonitorsResponse struct {HttpMonitors []*HTTPMonitor `protobuf:"bytes,1,rep,name=http_monitors,json=httpMonitors,proto3" json:"http_monitors,omitempty"`TcpMonitors []*TCPMonitor `protobuf:"bytes,2,rep,name=tcp_monitors,json=tcpMonitors,proto3" json:"tcp_monitors,omitempty"`DnsMonitors []*DNSMonitor `protobuf:"bytes,3,rep,name=dns_monitors,json=dnsMonitors,proto3" json:"dns_monitors,omitempty"`+ IcmpMonitors []*ICMPMonitor `protobuf:"bytes,5,rep,name=icmp_monitors,json=icmpMonitors,proto3" json:"icmp_monitors,omitempty"`Region string `protobuf:"bytes,4,opt,name=region,proto3" json:"region,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache@@ -118,6 +119,13 @@ func (x *MonitorsResponse) GetDnsMonitors() []*DNSMonitor {return nil}+func (x *MonitorsResponse) GetIcmpMonitors() []*ICMPMonitor {+ if x != nil {+ return x.IcmpMonitors+ }+ return nil+}+func (x *MonitorsResponse) GetRegion() string {if x != nil {return x.Region@@ -657,16 +665,201 @@ func (*IngestDNSResponse) Descriptor() ([]byte, []int) {return file_private_location_v1_private_location_proto_rawDescGZIP(), []int{8}}+type IngestICMPRequest struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`+ MonitorId string `protobuf:"bytes,2,opt,name=monitorId,proto3" json:"monitorId,omitempty"`+ Latency int64 `protobuf:"varint,3,opt,name=latency,proto3" json:"latency,omitempty"`+ LatencyMin int64 `protobuf:"varint,4,opt,name=latencyMin,proto3" json:"latencyMin,omitempty"`+ LatencyMax int64 `protobuf:"varint,5,opt,name=latencyMax,proto3" json:"latencyMax,omitempty"`+ PacketsSent int64 `protobuf:"varint,6,opt,name=packetsSent,proto3" json:"packetsSent,omitempty"`+ PacketsReceived int64 `protobuf:"varint,7,opt,name=packetsReceived,proto3" json:"packetsReceived,omitempty"`+ Timestamp int64 `protobuf:"varint,8,opt,name=timestamp,proto3" json:"timestamp,omitempty"`+ CronTimestamp int64 `protobuf:"varint,9,opt,name=cronTimestamp,proto3" json:"cronTimestamp,omitempty"`+ Uri string `protobuf:"bytes,10,opt,name=uri,proto3" json:"uri,omitempty"`+ Message string `protobuf:"bytes,11,opt,name=message,proto3" json:"message,omitempty"`+ RequestStatus string `protobuf:"bytes,12,opt,name=requestStatus,proto3" json:"requestStatus,omitempty"`+ Error int64 `protobuf:"varint,13,opt,name=error,proto3" json:"error,omitempty"`+ Timing string `protobuf:"bytes,14,opt,name=timing,proto3" json:"timing,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *IngestICMPRequest) Reset() {+ *x = IngestICMPRequest{}+ mi := &file_private_location_v1_private_location_proto_msgTypes[9]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *IngestICMPRequest) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*IngestICMPRequest) ProtoMessage() {}++func (x *IngestICMPRequest) ProtoReflect() protoreflect.Message {+ mi := &file_private_location_v1_private_location_proto_msgTypes[9]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use IngestICMPRequest.ProtoReflect.Descriptor instead.+func (*IngestICMPRequest) Descriptor() ([]byte, []int) {+ return file_private_location_v1_private_location_proto_rawDescGZIP(), []int{9}+}++func (x *IngestICMPRequest) GetId() string {+ if x != nil {+ return x.Id+ }+ return ""+}++func (x *IngestICMPRequest) GetMonitorId() string {+ if x != nil {+ return x.MonitorId+ }+ return ""+}++func (x *IngestICMPRequest) GetLatency() int64 {+ if x != nil {+ return x.Latency+ }+ return 0+}++func (x *IngestICMPRequest) GetLatencyMin() int64 {+ if x != nil {+ return x.LatencyMin+ }+ return 0+}++func (x *IngestICMPRequest) GetLatencyMax() int64 {+ if x != nil {+ return x.LatencyMax+ }+ return 0+}++func (x *IngestICMPRequest) GetPacketsSent() int64 {+ if x != nil {+ return x.PacketsSent+ }+ return 0+}++func (x *IngestICMPRequest) GetPacketsReceived() int64 {+ if x != nil {+ return x.PacketsReceived+ }+ return 0+}++func (x *IngestICMPRequest) GetTimestamp() int64 {+ if x != nil {+ return x.Timestamp+ }+ return 0+}++func (x *IngestICMPRequest) GetCronTimestamp() int64 {+ if x != nil {+ return x.CronTimestamp+ }+ return 0+}++func (x *IngestICMPRequest) GetUri() string {+ if x != nil {+ return x.Uri+ }+ return ""+}++func (x *IngestICMPRequest) GetMessage() string {+ if x != nil {+ return x.Message+ }+ return ""+}++func (x *IngestICMPRequest) GetRequestStatus() string {+ if x != nil {+ return x.RequestStatus+ }+ return ""+}++func (x *IngestICMPRequest) GetError() int64 {+ if x != nil {+ return x.Error+ }+ return 0+}++func (x *IngestICMPRequest) GetTiming() string {+ if x != nil {+ return x.Timing+ }+ return ""+}++type IngestICMPResponse struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *IngestICMPResponse) Reset() {+ *x = IngestICMPResponse{}+ mi := &file_private_location_v1_private_location_proto_msgTypes[10]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *IngestICMPResponse) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*IngestICMPResponse) ProtoMessage() {}++func (x *IngestICMPResponse) ProtoReflect() protoreflect.Message {+ mi := &file_private_location_v1_private_location_proto_msgTypes[10]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use IngestICMPResponse.ProtoReflect.Descriptor instead.+func (*IngestICMPResponse) Descriptor() ([]byte, []int) {+ return file_private_location_v1_private_location_proto_rawDescGZIP(), []int{10}+}+var File_private_location_v1_private_location_proto protoreflect.FileDescriptorconst file_private_location_v1_private_location_proto_rawDesc = "" +"\n" +- "*private_location/v1/private_location.proto\x12\x13private_location.v1\x1a%private_location/v1/dns_monitor.proto\x1a&private_location/v1/http_monitor.proto\x1a%private_location/v1/tcp_monitor.proto\"\x11\n" +- "\x0fMonitorsRequest\"\xf9\x01\n" ++ "*private_location/v1/private_location.proto\x12\x13private_location.v1\x1a%private_location/v1/dns_monitor.proto\x1a&private_location/v1/http_monitor.proto\x1a&private_location/v1/icmp_monitor.proto\x1a%private_location/v1/tcp_monitor.proto\"\x11\n" ++ "\x0fMonitorsRequest\"\xc0\x02\n" +"\x10MonitorsResponse\x12E\n" +"\rhttp_monitors\x18\x01 \x03(\v2 .private_location.v1.HTTPMonitorR\fhttpMonitors\x12B\n" +"\ftcp_monitors\x18\x02 \x03(\v2\x1f.private_location.v1.TCPMonitorR\vtcpMonitors\x12B\n" +- "\fdns_monitors\x18\x03 \x03(\v2\x1f.private_location.v1.DNSMonitorR\vdnsMonitors\x12\x16\n" ++ "\fdns_monitors\x18\x03 \x03(\v2\x1f.private_location.v1.DNSMonitorR\vdnsMonitors\x12E\n" ++ "\ricmp_monitors\x18\x05 \x03(\v2 .private_location.v1.ICMPMonitorR\ficmpMonitors\x12\x16\n" +"\x06region\x18\x04 \x01(\tR\x06region\"\x9e\x02\n" +"\x10IngestTCPRequest\x12\x0e\n" +"\x02id\x18\x01 \x01(\tR\x02id\x12\x1c\n" +@@ -717,13 +910,36 @@ const file_private_location_v1_private_location_proto_rawDesc = "" +"\fRecordsEntry\x12\x10\n" +"\x03key\x18\x01 \x01(\tR\x03key\x122\n" +"\x05value\x18\x02 \x01(\v2\x1c.private_location.v1.RecordsR\x05value:\x028\x01\"\x13\n" +- "\x11IngestDNSResponse2\x90\x03\n" ++ "\x11IngestDNSResponse\"\xab\x03\n" ++ "\x11IngestICMPRequest\x12\x0e\n" ++ "\x02id\x18\x01 \x01(\tR\x02id\x12\x1c\n" ++ "\tmonitorId\x18\x02 \x01(\tR\tmonitorId\x12\x18\n" ++ "\alatency\x18\x03 \x01(\x03R\alatency\x12\x1e\n" ++ "\n" ++ "latencyMin\x18\x04 \x01(\x03R\n" ++ "latencyMin\x12\x1e\n" ++ "\n" ++ "latencyMax\x18\x05 \x01(\x03R\n" ++ "latencyMax\x12 \n" ++ "\vpacketsSent\x18\x06 \x01(\x03R\vpacketsSent\x12(\n" ++ "\x0fpacketsReceived\x18\a \x01(\x03R\x0fpacketsReceived\x12\x1c\n" ++ "\ttimestamp\x18\b \x01(\x03R\ttimestamp\x12$\n" ++ "\rcronTimestamp\x18\t \x01(\x03R\rcronTimestamp\x12\x10\n" ++ "\x03uri\x18\n" ++ " \x01(\tR\x03uri\x12\x18\n" ++ "\amessage\x18\v \x01(\tR\amessage\x12$\n" ++ "\rrequestStatus\x18\f \x01(\tR\rrequestStatus\x12\x14\n" ++ "\x05error\x18\r \x01(\x03R\x05error\x12\x16\n" ++ "\x06timing\x18\x0e \x01(\tR\x06timing\"\x14\n" ++ "\x12IngestICMPResponse2\xf1\x03\n" +"\x16PrivateLocationService\x12Y\n" +"\bMonitors\x12$.private_location.v1.MonitorsRequest\x1a%.private_location.v1.MonitorsResponse\"\x00\x12\\\n" +"\tIngestTCP\x12%.private_location.v1.IngestTCPRequest\x1a&.private_location.v1.IngestTCPResponse\"\x00\x12_\n" +"\n" +"IngestHTTP\x12&.private_location.v1.IngestHTTPRequest\x1a'.private_location.v1.IngestHTTPResponse\"\x00\x12\\\n" +- "\tIngestDNS\x12%.private_location.v1.IngestDNSRequest\x1a&.private_location.v1.IngestDNSResponse\"\x00BJZHgithub.com/openstatushq/openstatus/packages/proto/private_location/v1;v1b\x06proto3"+ "\tIngestDNS\x12%.private_location.v1.IngestDNSRequest\x1a&.private_location.v1.IngestDNSResponse\"\x00\x12_\n" ++ "\n" ++ "IngestICMP\x12&.private_location.v1.IngestICMPRequest\x1a'.private_location.v1.IngestICMPResponse\"\x00BJZHgithub.com/openstatushq/openstatus/packages/proto/private_location/v1;v1b\x06proto3"var (file_private_location_v1_private_location_proto_rawDescOnce sync.Once@@ -737,7 +953,7 @@ func file_private_location_v1_private_location_proto_rawDescGZIP() []byte {return file_private_location_v1_private_location_proto_rawDescData}-var file_private_location_v1_private_location_proto_msgTypes = make([]protoimpl.MessageInfo, 10)+var file_private_location_v1_private_location_proto_msgTypes = make([]protoimpl.MessageInfo, 12)var file_private_location_v1_private_location_proto_goTypes = []any{(*MonitorsRequest)(nil), // 0: private_location.v1.MonitorsRequest(*MonitorsResponse)(nil), // 1: private_location.v1.MonitorsResponse@@ -748,30 +964,36 @@ var file_private_location_v1_private_location_proto_goTypes = []any{(*Records)(nil), // 6: private_location.v1.Records(*IngestDNSRequest)(nil), // 7: private_location.v1.IngestDNSRequest(*IngestDNSResponse)(nil), // 8: private_location.v1.IngestDNSResponse- nil, // 9: private_location.v1.IngestDNSRequest.RecordsEntry- (*HTTPMonitor)(nil), // 10: private_location.v1.HTTPMonitor- (*TCPMonitor)(nil), // 11: private_location.v1.TCPMonitor- (*DNSMonitor)(nil), // 12: private_location.v1.DNSMonitor+ (*IngestICMPRequest)(nil), // 9: private_location.v1.IngestICMPRequest+ (*IngestICMPResponse)(nil), // 10: private_location.v1.IngestICMPResponse+ nil, // 11: private_location.v1.IngestDNSRequest.RecordsEntry+ (*HTTPMonitor)(nil), // 12: private_location.v1.HTTPMonitor+ (*TCPMonitor)(nil), // 13: private_location.v1.TCPMonitor+ (*DNSMonitor)(nil), // 14: private_location.v1.DNSMonitor+ (*ICMPMonitor)(nil), // 15: private_location.v1.ICMPMonitor}var file_private_location_v1_private_location_proto_depIdxs = []int32{- 10, // 0: private_location.v1.MonitorsResponse.http_monitors:type_name -> private_location.v1.HTTPMonitor- 11, // 1: private_location.v1.MonitorsResponse.tcp_monitors:type_name -> private_location.v1.TCPMonitor- 12, // 2: private_location.v1.MonitorsResponse.dns_monitors:type_name -> private_location.v1.DNSMonitor- 9, // 3: private_location.v1.IngestDNSRequest.records:type_name -> private_location.v1.IngestDNSRequest.RecordsEntry- 6, // 4: private_location.v1.IngestDNSRequest.RecordsEntry.value:type_name -> private_location.v1.Records- 0, // 5: private_location.v1.PrivateLocationService.Monitors:input_type -> private_location.v1.MonitorsRequest- 2, // 6: private_location.v1.PrivateLocationService.IngestTCP:input_type -> private_location.v1.IngestTCPRequest- 4, // 7: private_location.v1.PrivateLocationService.IngestHTTP:input_type -> private_location.v1.IngestHTTPRequest- 7, // 8: private_location.v1.PrivateLocationService.IngestDNS:input_type -> private_location.v1.IngestDNSRequest- 1, // 9: private_location.v1.PrivateLocationService.Monitors:output_type -> private_location.v1.MonitorsResponse- 3, // 10: private_location.v1.PrivateLocationService.IngestTCP:output_type -> private_location.v1.IngestTCPResponse- 5, // 11: private_location.v1.PrivateLocationService.IngestHTTP:output_type -> private_location.v1.IngestHTTPResponse- 8, // 12: private_location.v1.PrivateLocationService.IngestDNS:output_type -> private_location.v1.IngestDNSResponse- 9, // [9:13] is the sub-list for method output_type- 5, // [5:9] is the sub-list for method input_type- 5, // [5:5] is the sub-list for extension type_name- 5, // [5:5] is the sub-list for extension extendee- 0, // [0:5] is the sub-list for field type_name+ 12, // 0: private_location.v1.MonitorsResponse.http_monitors:type_name -> private_location.v1.HTTPMonitor+ 13, // 1: private_location.v1.MonitorsResponse.tcp_monitors:type_name -> private_location.v1.TCPMonitor+ 14, // 2: private_location.v1.MonitorsResponse.dns_monitors:type_name -> private_location.v1.DNSMonitor+ 15, // 3: private_location.v1.MonitorsResponse.icmp_monitors:type_name -> private_location.v1.ICMPMonitor+ 11, // 4: private_location.v1.IngestDNSRequest.records:type_name -> private_location.v1.IngestDNSRequest.RecordsEntry+ 6, // 5: private_location.v1.IngestDNSRequest.RecordsEntry.value:type_name -> private_location.v1.Records+ 0, // 6: private_location.v1.PrivateLocationService.Monitors:input_type -> private_location.v1.MonitorsRequest+ 2, // 7: private_location.v1.PrivateLocationService.IngestTCP:input_type -> private_location.v1.IngestTCPRequest+ 4, // 8: private_location.v1.PrivateLocationService.IngestHTTP:input_type -> private_location.v1.IngestHTTPRequest+ 7, // 9: private_location.v1.PrivateLocationService.IngestDNS:input_type -> private_location.v1.IngestDNSRequest+ 9, // 10: private_location.v1.PrivateLocationService.IngestICMP:input_type -> private_location.v1.IngestICMPRequest+ 1, // 11: private_location.v1.PrivateLocationService.Monitors:output_type -> private_location.v1.MonitorsResponse+ 3, // 12: private_location.v1.PrivateLocationService.IngestTCP:output_type -> private_location.v1.IngestTCPResponse+ 5, // 13: private_location.v1.PrivateLocationService.IngestHTTP:output_type -> private_location.v1.IngestHTTPResponse+ 8, // 14: private_location.v1.PrivateLocationService.IngestDNS:output_type -> private_location.v1.IngestDNSResponse+ 10, // 15: private_location.v1.PrivateLocationService.IngestICMP:output_type -> private_location.v1.IngestICMPResponse+ 11, // [11:16] is the sub-list for method output_type+ 6, // [6:11] is the sub-list for method input_type+ 6, // [6:6] is the sub-list for extension type_name+ 6, // [6:6] is the sub-list for extension extendee+ 0, // [0:6] is the sub-list for field type_name}func init() { file_private_location_v1_private_location_proto_init() }@@ -781,6 +1003,7 @@ func file_private_location_v1_private_location_proto_init() {}file_private_location_v1_dns_monitor_proto_init()file_private_location_v1_http_monitor_proto_init()+ file_private_location_v1_icmp_monitor_proto_init()file_private_location_v1_tcp_monitor_proto_init()type x struct{}out := protoimpl.TypeBuilder{@@ -788,7 +1011,7 @@ func file_private_location_v1_private_location_proto_init() {GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: unsafe.Slice(unsafe.StringData(file_private_location_v1_private_location_proto_rawDesc), len(file_private_location_v1_private_location_proto_rawDesc)),NumEnums: 0,- NumMessages: 10,+ NumMessages: 12,NumExtensions: 0,NumServices: 1,},diff --git a/apps/checker/request/request.go b/apps/checker/request/request.goindex 2828e3342..ac5b9626c 100644--- a/apps/checker/request/request.go+++ b/apps/checker/request/request.go@@ -108,6 +108,23 @@ type TCPCheckerRequest struct {} `json:"otelConfig"`}+type ICMPCheckerRequest struct {+ Status string `json:"status"`+ WorkspaceID string `json:"workspaceId"`+ URI string `json:"uri"`+ MonitorID string `json:"monitorId"`+ Trigger string `json:"trigger,omitempty"`+ RequestId int64 `json:"requestId,omitempty"`+ CronTimestamp int64 `json:"cronTimestamp"`+ Timeout int64 `json:"timeout"`+ DegradedAfter int64 `json:"degradedAfter,omitempty"`+ Retry int64 `json:"retry,omitempty"`+ OtelConfig struct {+ Endpoint string `json:"endpoint"`+ Headers map[string]string `json:"headers,omitempty"`+ } `json:"otelConfig"`+}+type TCPRequest struct {WorkspaceID string `json:"workspaceId"`URL string `json:"url"`diff --git a/apps/dashboard/src/app/(dashboard)/monitors/[id]/logs/client.tsx b/apps/dashboard/src/app/(dashboard)/monitors/[id]/logs/client.tsxindex 5afeb6c15..26680f149 100644--- a/apps/dashboard/src/app/(dashboard)/monitors/[id]/logs/client.tsx+++ b/apps/dashboard/src/app/(dashboard)/monitors/[id]/logs/client.tsx@@ -131,7 +131,9 @@ export function Client() {setPagination={setPagination}paginationComponent={DataTablePagination}defaultColumnVisibility={- monitor.jobType === "tcp" || monitor.jobType === "dns"+ monitor.jobType === "tcp" ||+ monitor.jobType === "dns" ||+ monitor.jobType === "icmp"? { timing: false, statusCode: false }: {}}diff --git a/apps/dashboard/src/app/(dashboard)/monitors/[id]/nav-actions.tsx b/apps/dashboard/src/app/(dashboard)/monitors/[id]/nav-actions.tsxindex 6a1a7517e..7197d2c87 100644--- a/apps/dashboard/src/app/(dashboard)/monitors/[id]/nav-actions.tsx+++ b/apps/dashboard/src/app/(dashboard)/monitors/[id]/nav-actions.tsx@@ -26,10 +26,13 @@ import { useTRPC } from "@/lib/trpc/client";type TestTCP = RouterOutputs["checker"]["testTcp"];type TestHTTP = RouterOutputs["checker"]["testHttp"];type TestDNS = RouterOutputs["checker"]["testDns"];+type TestICMP = RouterOutputs["checker"]["testIcmp"];export function NavActions() {const { id } = useParams<{ id: string }>();- const [test, setTest] = useState<TestTCP | TestHTTP | TestDNS | null>(null);+ const [test, setTest] = useState<+ TestTCP | TestHTTP | TestDNS | TestICMP | null+ >(null);const queryClient = useQueryClient();const trpc = useTRPC();const router = useRouter();@@ -66,6 +69,7 @@ export function NavActions() {const testHttpMutation = useMutation(trpc.checker.testHttp.mutationOptions());const testTcpMutation = useMutation(trpc.checker.testTcp.mutationOptions());const testDnsMutation = useMutation(trpc.checker.testDns.mutationOptions());+ const testIcmpMutation = useMutation(trpc.checker.testIcmp.mutationOptions());// curl only speaks HTTP — the action is hidden for tcp/dns monitorsconst curlCommand =@@ -160,6 +164,22 @@ export function NavActions() {return "DNS test failed";},});+ } else if (monitor?.jobType === "icmp") {+ const promise = testIcmpMutation.mutateAsync({ url: monitor.url });++ toast.promise(promise, {+ loading: "Testing ICMP request...",+ success: (data) => {+ setTest(data);+ return "ICMP test completed successfully";+ },+ error: (error) => {+ if (isTRPCClientError(error)) {+ return error.message;+ }+ return "ICMP test failed";+ },+ });}}diff --git a/apps/dashboard/src/app/(dashboard)/monitors/[id]/overview/client.tsx b/apps/dashboard/src/app/(dashboard)/monitors/[id]/overview/client.tsxindex 0b9f5167b..35e9c6add 100644--- a/apps/dashboard/src/app/(dashboard)/monitors/[id]/overview/client.tsx+++ b/apps/dashboard/src/app/(dashboard)/monitors/[id]/overview/client.tsx@@ -83,7 +83,7 @@ export function Client() {...trpc.tinybird.metricsRegions.queryOptions({monitorId: id,period: effectivePeriod,- type: (monitor?.jobType ?? "http") as "http" | "tcp",+ type: (monitor?.jobType ?? "http") as "http" | "tcp" | "dns" | "icmp",regions: selectedRegions,// bucket by period (daily at 30d/90d) to keep payload + chart readableinterval: periodToInterval[effectivePeriod],@@ -144,7 +144,7 @@ export function Client() {</div><GlobalUptimeSectionmonitorId={id}- jobType={monitor.jobType as "http" | "tcp"}+ jobType={monitor.jobType as "http" | "tcp" | "dns" | "icmp"}period={effectivePeriod}regions={selectedRegions}/>@@ -158,7 +158,7 @@ export function Client() {</SectionHeader><ChartBarUptimemonitorId={id}- type={monitor.jobType as "http" | "tcp"}+ type={monitor.jobType as "http" | "tcp" | "dns" | "icmp"}period={effectivePeriod}regions={selectedRegions}/>@@ -197,7 +197,7 @@ export function Client() {monitorId={id}percentile={percentile}degradedAfter={monitor.degradedAfter}- type={monitor.jobType as "http" | "tcp"}+ type={monitor.jobType as "http" | "tcp" | "dns" | "icmp"}period={effectivePeriod}regions={selectedRegions}/>diff --git a/apps/dashboard/src/components/chart/chart-area-latency.tsx b/apps/dashboard/src/components/chart/chart-area-latency.tsxindex 98cb3d706..b1dfc8887 100644--- a/apps/dashboard/src/components/chart/chart-area-latency.tsx+++ b/apps/dashboard/src/components/chart/chart-area-latency.tsx@@ -51,7 +51,7 @@ export function ChartAreaLatency({degradedAfter: number | null;percentile: (typeof PERCENTILES)[number];period: (typeof PERIODS)[number];- type: "http" | "tcp";+ type: "http" | "tcp" | "dns" | "icmp";regions: string[] | undefined;}) {const trpc = useTRPC();diff --git a/apps/dashboard/src/components/chart/chart-bar-uptime-light.tsx b/apps/dashboard/src/components/chart/chart-bar-uptime-light.tsxindex 7f8493fc5..ac4672c72 100644--- a/apps/dashboard/src/components/chart/chart-bar-uptime-light.tsx+++ b/apps/dashboard/src/components/chart/chart-bar-uptime-light.tsx@@ -36,7 +36,7 @@ export function ChartBarUptimeLight({regions,}: {monitorId: string;- type: "http" | "tcp";+ type: "http" | "tcp" | "dns" | "icmp";regions?: Region[];}) {const trpc = useTRPC();diff --git a/apps/dashboard/src/components/chart/chart-bar-uptime.tsx b/apps/dashboard/src/components/chart/chart-bar-uptime.tsxindex f408334ae..cfbb1f7eb 100644--- a/apps/dashboard/src/components/chart/chart-bar-uptime.tsx+++ b/apps/dashboard/src/components/chart/chart-bar-uptime.tsx@@ -44,7 +44,7 @@ export function ChartBarUptime({}: {monitorId: string;period: (typeof PERIODS)[number];- type: "http" | "tcp";+ type: "http" | "tcp" | "dns" | "icmp";regions: string[] | undefined;}) {const isMobile = useIsMobile();diff --git a/apps/dashboard/src/components/data-table/response-logs/data-table-basics.tsx b/apps/dashboard/src/components/data-table/response-logs/data-table-basics.tsxindex debc22e62..41f23c055 100644--- a/apps/dashboard/src/components/data-table/response-logs/data-table-basics.tsx+++ b/apps/dashboard/src/components/data-table/response-logs/data-table-basics.tsx@@ -50,6 +50,11 @@ export function DataTableBasics({<DataTableBasicsDNS data={data} privateLocations={privateLocations} />);}+ if (data.type === "icmp") {+ return (+ <DataTableBasicsICMP data={data} privateLocations={privateLocations} />+ );+ }return null;}@@ -467,6 +472,170 @@ export function DataTableBasicsTCP({);}+export function DataTableBasicsICMP({+ data,+ privateLocations,+}: {+ data: Extract<ResponseLog, { type: "icmp" }> & {+ trigger?: "cron" | "api" | "test" | null;+ };+ privateLocations?: PrivateLocation[];+}) {+ const privateLocataion = privateLocations?.find(+ (location) => String(location.id) === String(data.region),+ );+ const regionConfig = getRegionInfo(data.region, {+ location: privateLocataion?.name,+ });+ const packetLoss =+ data.packetsSent > 0+ ? (data.packetsSent - data.packetsReceived) / data.packetsSent+ : 0;+ return (+ <Table className="table-fixed">+ <colgroup>+ <col className="w-1/3" />+ <col className="w-2/3" />+ </colgroup>+ <TableBody>+ <TableRow>+ <TableHead colSpan={2}>Request</TableHead>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Result+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ <div className="flex items-center gap-2">+ <div+ className={cn("bg-muted h-2.5 w-2.5 rounded-[2px]", {+ "bg-destructive": data?.requestStatus === "error",+ "bg-warning": data?.requestStatus === "degraded",+ "bg-success": data?.requestStatus === "success",+ })}+ />+ <div className="capitalize">+ {data?.requestStatus ?? "unknown"}+ </div>+ </div>+ </TableCell>+ </TableRow>+ {data.id ? (+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ ID+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ {data.id}+ </TableCell>+ </TableRow>+ ) : null}+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Timestamp+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ <TableCellDate+ value={new Date(data.cronTimestamp)}+ className="text-foreground"+ />+ </TableCell>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Host+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ {data.uri}+ </TableCell>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Latency (avg)+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ <TableCellNumber value={data?.latency} unit="ms" />+ </TableCell>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Latency (min / max)+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ {formatMilliseconds(data.latencyMin)} /{" "}+ {formatMilliseconds(data.latencyMax)}+ </TableCell>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Packets+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ {data.packetsReceived} / {data.packetsSent} received+ </TableCell>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Packet Loss+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ {formatPercentage(packetLoss)}+ </TableCell>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Region+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ {regionConfig?.flag} {regionConfig?.code}{" "}+ <span className="text-muted-foreground">+ {regionConfig?.location}+ </span>+ </TableCell>+ </TableRow>+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Cloud Provider+ </TableHead>+ <TableCell className="inline-flex max-w-full overflow-x-auto font-mono whitespace-normal">+ <IconCloudProvider+ provider={regionConfig?.provider}+ className="mt-0.5"+ />+ <span className="text-muted-foreground ml-1">+ {regionConfig?.provider}+ </span>+ </TableCell>+ </TableRow>+ {data.trigger ? (+ <TableRow className="[&>:not(:last-child)]:border-r">+ <TableHead className="bg-muted/50 text-muted-foreground font-normal">+ Trigger+ </TableHead>+ <TableCell className="max-w-full overflow-x-auto font-mono whitespace-normal">+ {data?.trigger}+ </TableCell>+ </TableRow>+ ) : null}+ {data?.errorMessage ? (+ <>+ <TableRow>+ <TableHead colSpan={2}>Error Message</TableHead>+ </TableRow>+ <TableRow>+ <TableCell colSpan={2} className="p-0">+ <pre className="bg-muted/50 max-w-full overflow-x-auto rounded-none p-2 font-mono text-sm whitespace-pre-wrap">+ {data.errorMessage}+ </pre>+ </TableCell>+ </TableRow>+ </>+ ) : null}+ </TableBody>+ </Table>+ );+}+export function DataTableBasicsDNS({data,privateLocations,diff --git a/apps/dashboard/src/components/data-table/response-logs/data-table-sheet-test.tsx b/apps/dashboard/src/components/data-table/response-logs/data-table-sheet-test.tsxindex b01dd7013..71ecdfddd 100644--- a/apps/dashboard/src/components/data-table/response-logs/data-table-sheet-test.tsx+++ b/apps/dashboard/src/components/data-table/response-logs/data-table-sheet-test.tsx@@ -15,6 +15,7 @@ import { DataTableBasics } from "./data-table-basics";type TestTCP = RouterOutputs["checker"]["testTcp"];type TestHTTP = RouterOutputs["checker"]["testHttp"];type TestDNS = RouterOutputs["checker"]["testDns"];+type TestICMP = RouterOutputs["checker"]["testIcmp"];type Monitor = NonNullable<RouterOutputs["monitor"]["get"]>;export function DataTableSheetTest({@@ -22,7 +23,7 @@ export function DataTableSheetTest({monitor,onClose,}: {- data: TestTCP | TestHTTP | TestDNS | null;+ data: TestTCP | TestHTTP | TestDNS | TestICMP | null;monitor: Monitor;onClose: () => void;}) {@@ -45,7 +46,10 @@ export function DataTableSheetTest({);}-function mapping(data: TestTCP | TestHTTP | TestDNS, monitor: Monitor) {+function mapping(+ data: TestTCP | TestHTTP | TestDNS | TestICMP,+ monitor: Monitor,+) {switch (data.type) {case "http":return {@@ -102,6 +106,26 @@ function mapping(data: TestTCP | TestHTTP | TestDNS, monitor: Monitor) {errorMessage: null,assertions: null,} as const;+ case "icmp":+ return {+ id: null,+ trigger: null,+ timestamp: data.timestamp,+ cronTimestamp: data.timestamp,+ region: data.region,+ type: data.type,+ requestStatus: "success",+ error: false,+ latency: data.latency ?? 0,+ latencyMin: data.latencyMin ?? 0,+ latencyMax: data.latencyMax ?? 0,+ packetsSent: data.packetsSent ?? 0,+ packetsReceived: data.packetsReceived ?? 0,+ uri: monitor.url,+ monitorId: String(monitor.id),+ errorMessage: null,+ assertions: null,+ } as const;default:return null;}diff --git a/apps/dashboard/src/components/forms/monitor/form-general.tsx b/apps/dashboard/src/components/forms/monitor/form-general.tsxindex 70179e263..5233f2d60 100644--- a/apps/dashboard/src/components/forms/monitor/form-general.tsx+++ b/apps/dashboard/src/components/forms/monitor/form-general.tsx@@ -13,7 +13,7 @@ import {textBodyAssertion,} from "@openstatus/assertions";import { monitorMethods } from "@openstatus/db/src/schema/monitors/constants";-import { Globe, Network, Add, Server, Close } from "@openstatus/icons";+import { Globe, Network, Add, Speed, Server, Close } from "@openstatus/icons";import {AlertDialog,AlertDialogAction,@@ -72,7 +72,7 @@ import {FormCardTitle,} from "@/components/forms/form-card";-const TYPES = ["http", "tcp", "dns"] as const;+const TYPES = ["http", "tcp", "dns", "icmp"] as const;const HTTP_ASSERTION_TYPES = ["status", "header", "textBody"] as const;const DNS_ASSERTION_TYPES = dnsRecords;@@ -273,13 +273,14 @@ export function FormGeneral({<RadioGrouponValueChange={field.onChange}defaultValue={field.value}- className="grid grid-cols-2 gap-4 sm:grid-cols-4"+ className="grid grid-cols-2 gap-4 sm:grid-cols-5"disabled={!!defaultValues?.type}>{[{ value: "http", icon: Globe, label: "HTTP" },{ value: "tcp", icon: Network, label: "TCP" },{ value: "dns", icon: Server, label: "DNS" },+ { value: "icmp", icon: Speed, label: "ICMP" },].map((type) => {return (<Tooltip key={type.value}>@@ -724,6 +725,48 @@ export function FormGeneral({</div></FormCardContent>)}+ {watchType === "icmp" && (+ <FormCardContent className="grid gap-4 sm:grid-cols-3">+ <FormField+ control={form.control}+ name="url"+ render={({ field }) => (+ <FormItem className="sm:col-span-2">+ <FormLabel>Host</FormLabel>+ <FormControl>+ <Input placeholder="1.1.1.1" {...field} />+ </FormControl>+ <FormMessage />+ <FormDescription>+ The host to ping. Supports a domain, IPv4, or IPv6 address+ (no port).+ </FormDescription>+ </FormItem>+ )}+ />+ <div className="text-muted-foreground col-span-full text-sm">+ Examples:+ <ul className="list-inside list-disc">+ <li>+ Domain:{" "}+ <span className="text-foreground font-mono">+ openstatus.dev+ </span>+ </li>+ <li>+ IPv4:{" "}+ <span className="text-foreground font-mono">1.1.1.1</span>+ </li>+ <li>+ IPv6:{" "}+ <span className="text-foreground font-mono">+ 2001:4860:4860::8888+ </span>+ </li>+ </ul>+ </div>+ </FormCardContent>+ )}{watchType === "dns" && (<><FormCardContent className="grid gap-4 sm:grid-cols-3">diff --git a/apps/dashboard/src/components/forms/monitor/update.tsx b/apps/dashboard/src/components/forms/monitor/update.tsxindex 7a23f94e9..071607f47 100644--- a/apps/dashboard/src/components/forms/monitor/update.tsx+++ b/apps/dashboard/src/components/forms/monitor/update.tsx@@ -119,7 +119,7 @@ export function FormMonitorUpdate() {<FormCardGroup><FormGeneraldefaultValues={{- type: monitor.jobType as "http" | "tcp",+ type: monitor.jobType as "http" | "tcp" | "dns" | "icmp",url: monitor.url,name: monitor.name,method: monitor.method as "GET" | "POST" | "PUT" | "PATCH" | "DELETE",diff --git a/apps/dashboard/src/components/metric/global-uptime/section.tsx b/apps/dashboard/src/components/metric/global-uptime/section.tsxindex 9290ed7d6..807d7367d 100644--- a/apps/dashboard/src/components/metric/global-uptime/section.tsx+++ b/apps/dashboard/src/components/metric/global-uptime/section.tsx@@ -37,7 +37,7 @@ export function GlobalUptimeSection({regions,}: {monitorId: string;- jobType: "http" | "tcp";+ jobType: "http" | "tcp" | "dns" | "icmp";period: (typeof PERIODS)[number];regions: string[] | undefined;}) {diff --git a/apps/dashboard/src/data/monitors.client.ts b/apps/dashboard/src/data/monitors.client.tsindex 0840d88a3..e59e8dbb8 100644--- a/apps/dashboard/src/data/monitors.client.ts+++ b/apps/dashboard/src/data/monitors.client.ts@@ -4,6 +4,7 @@ import {Duplicate,Globe,Network,+ Speed,Server,Terminal,Delete,@@ -25,6 +26,11 @@ export const monitorTypes = [label: "DNS",icon: Server,},+ {+ id: "icmp",+ label: "ICMP",+ icon: Speed,+ },] as const;export const actions = [diff --git a/apps/private-location/README.md b/apps/private-location/README.mdindex 1c5de3baa..7c1eb9a44 100644--- a/apps/private-location/README.md+++ b/apps/private-location/README.md@@ -2,3 +2,17 @@A server that allows private regions to register and ingest data from them.++## ICMP monitors++ICMP (ping) monitors run from the checker agent. Sending ICMP echo requests+needs one of the following on the host running the agent:++- **Unprivileged datagram sockets** — set `net.ipv4.ping_group_range` to a range+ that includes the agent's GID (e.g. `sysctl -w net.ipv4.ping_group_range="0 2147483647"`).+ The agent prefers this path and needs no elevated capabilities.+- **Raw sockets** — grant the binary `CAP_NET_RAW` (`setcap cap_net_raw+ep <binary>`)+ or run it as root. The agent falls back to this automatically when datagram+ sockets are unavailable.++Without either, ICMP checks fail to open a socket and are reported as errors.diff --git a/apps/private-location/internal/database/models.go b/apps/private-location/internal/database/models.goindex 037a2b4f8..9334198c3 100644--- a/apps/private-location/internal/database/models.go+++ b/apps/private-location/internal/database/models.go@@ -10,6 +10,7 @@ const (JobTypeUDP JobType = "udp"JobTypeHTTP JobType = "http"JobTypeDNS JobType = "dns"+ JobTypeICMP JobType = "icmp")type Monitor struct {diff --git a/apps/private-location/internal/server/ingest_icmp.go b/apps/private-location/internal/server/ingest_icmp.gonew file mode 100644index 000000000..1a66a70c9--- /dev/null+++ b/apps/private-location/internal/server/ingest_icmp.go@@ -0,0 +1,91 @@+package server++import (+ "context"+ "strconv"++ "connectrpc.com/connect"+ "github.com/openstatushq/openstatus/apps/private-location/internal/tinybird"+ private_locationv1 "github.com/openstatushq/openstatus/apps/private-location/proto/private_location/v1"+)++type ICMPData struct {+ ID string `json:"id"`+ Timing string `json:"timing"`+ ErrorMessage string `json:"errorMessage"`+ Region string `json:"region"`+ Trigger string `json:"trigger"`+ URI string `json:"uri"`+ RequestStatus string `json:"requestStatus,omitempty"`++ RequestId int64 `json:"requestId,omitempty"`+ WorkspaceID int64 `json:"workspaceId"`+ MonitorID int64 `json:"monitorId"`+ Timestamp int64 `json:"timestamp"`+ Latency int64 `json:"latency"`+ LatencyMin int64 `json:"latencyMin"`+ LatencyMax int64 `json:"latencyMax"`+ CronTimestamp int64 `json:"cronTimestamp"`++ PacketsSent uint8 `json:"packetsSent"`+ PacketsReceived uint8 `json:"packetsReceived"`++ Error uint8 `json:"error"`+}++func (h *privateLocationHandler) IngestICMP(ctx context.Context, req *connect.Request[private_locationv1.IngestICMPRequest]) (*connect.Response[private_locationv1.IngestICMPResponse], error) {+ token := req.Header().Get("openstatus-token")+ if token == "" {+ return nil, connect.NewError(connect.CodeUnauthenticated, ErrMissingToken)+ }++ if err := ValidateIngestICMPRequest(req.Msg); err != nil {+ return nil, NewValidationError(err)+ }++ ic, err := h.getIngestContext(ctx, token, req.Msg.MonitorId)+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, err)+ }++ // Enrich wide event with business context+ if holder := GetEvent(ctx); holder != nil {+ holder.Event["private_location"] = map[string]any{+ "monitor_id": req.Msg.MonitorId,+ "workspace_id": ic.Monitor.WorkspaceID,+ "region_id": ic.Region.ID,+ "datasource": tinybird.DatasourceICMP,+ }+ }++ data := ICMPData{+ ID: req.Msg.Id,+ WorkspaceID: int64(ic.Monitor.WorkspaceID),+ Timestamp: req.Msg.Timestamp,+ Error: uint8(req.Msg.Error),+ Region: strconv.Itoa(ic.Region.ID),+ MonitorID: int64(ic.Monitor.ID),+ Timing: req.Msg.Timing,+ Latency: req.Msg.Latency,+ LatencyMin: req.Msg.LatencyMin,+ LatencyMax: req.Msg.LatencyMax,+ PacketsSent: uint8(req.Msg.PacketsSent),+ PacketsReceived: uint8(req.Msg.PacketsReceived),+ CronTimestamp: req.Msg.CronTimestamp,+ Trigger: "cron",+ URI: req.Msg.Uri,+ RequestStatus: req.Msg.RequestStatus,+ }++ h.sendEventAndUpdateLastSeen(ctx, data, tinybird.DatasourceICMP, ic.Region.ID)++ h.forwardStatusUpdate(ctx, ic, statusUpdateInput{+ RequestStatus: data.RequestStatus,+ Message: data.ErrorMessage,+ Latency: data.Latency,+ CronTimestamp: data.CronTimestamp,+ ErrorFlag: data.Error,+ })++ return connect.NewResponse(&private_locationv1.IngestICMPResponse{}), nil+}diff --git a/apps/private-location/internal/server/monitors.go b/apps/private-location/internal/server/monitors.goindex e227e02c7..04cece34a 100644--- a/apps/private-location/internal/server/monitors.go+++ b/apps/private-location/internal/server/monitors.go@@ -195,7 +195,7 @@ func (h *privateLocationHandler) Monitors(ctx context.Context, req *connect.Requif err != nil {return nil, connect.NewError(connect.CodeInternal, err)}- httpMonitors, tcpMonitors, dnsMonitors, workspaceId := mapMonitors(ctx, monitors)+ httpMonitors, tcpMonitors, dnsMonitors, icmpMonitors, workspaceId := mapMonitors(ctx, monitors)// Enrich wide event with monitor countsif holder := GetEvent(ctx); holder != nil {@@ -204,6 +204,7 @@ func (h *privateLocationHandler) Monitors(ctx context.Context, req *connect.Requ"http_monitors": len(httpMonitors),"tcp_monitors": len(tcpMonitors),"dns_monitors": len(dnsMonitors),+ "icmp_monitors": len(icmpMonitors),"total_monitors": len(monitors),}}@@ -212,6 +213,7 @@ func (h *privateLocationHandler) Monitors(ctx context.Context, req *connect.RequHttpMonitors: httpMonitors,TcpMonitors: tcpMonitors,DnsMonitors: dnsMonitors,+ IcmpMonitors: icmpMonitors,Region: location.Name,}), nil}@@ -220,12 +222,14 @@ func mapMonitors(ctx context.Context, monitors []database.Monitor) ([]*private_locationv1.HTTPMonitor,[]*private_locationv1.TCPMonitor,[]*private_locationv1.DNSMonitor,+ []*private_locationv1.ICMPMonitor,int,) {var workspaceId intvar httpMonitors []*private_locationv1.HTTPMonitorvar tcpMonitors []*private_locationv1.TCPMonitorvar dnsMonitors []*private_locationv1.DNSMonitor+ var icmpMonitors []*private_locationv1.ICMPMonitorfor _, monitor := range monitors {if workspaceId == 0 {workspaceId = monitor.WorkspaceID@@ -238,10 +242,12 @@ func mapMonitors(ctx context.Context, monitors []database.Monitor) (tcpMonitors = append(tcpMonitors, toTCPMonitor(ctx, monitor))case database.JobTypeDNS:dnsMonitors = append(dnsMonitors, toDNSMonitor(ctx, monitor))+ case database.JobTypeICMP:+ icmpMonitors = append(icmpMonitors, toICMPMonitor(ctx, monitor))}}- return httpMonitors, tcpMonitors, dnsMonitors, workspaceId+ return httpMonitors, tcpMonitors, dnsMonitors, icmpMonitors, workspaceId}func toHTTPMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.HTTPMonitor {@@ -283,6 +289,18 @@ func toTCPMonitor(ctx context.Context, monitor database.Monitor) *private_locati}}+func toICMPMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.ICMPMonitor {+ return &private_locationv1.ICMPMonitor{+ Id: strconv.Itoa(monitor.ID),+ Uri: monitor.URL,+ Timeout: monitor.Timeout,+ DegradedAt: &monitor.DegradedAfter.Int64,+ Periodicity: monitor.Periodicity,+ Retry: int64(monitor.Retry),+ OtelConfig: buildOtelConfig(ctx, monitor),+ }+}+func toDNSMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.DNSMonitor {return &private_locationv1.DNSMonitor{Id: strconv.Itoa(monitor.ID),diff --git a/apps/private-location/internal/server/validation.go b/apps/private-location/internal/server/validation.goindex 43e42b6f4..cf9f11f2c 100644--- a/apps/private-location/internal/server/validation.go+++ b/apps/private-location/internal/server/validation.go@@ -58,6 +58,20 @@ func ValidateIngestDNSRequest(req *private_locationv1.IngestDNSRequest) error {return nil}+// ValidateIngestICMPRequest validates an ICMP ingest request+func ValidateIngestICMPRequest(req *private_locationv1.IngestICMPRequest) error {+ if req.MonitorId == "" {+ return ErrEmptyMonitorID+ }+ if req.Latency < 0 {+ return ErrInvalidLatency+ }+ if req.Timestamp <= 0 {+ return ErrInvalidTimestamp+ }+ return nil+}+// NewValidationError creates a Connect error for validation failuresfunc NewValidationError(err error) *connect.Error {return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("validation error: %w", err))diff --git a/apps/private-location/internal/tinybird/client.go b/apps/private-location/internal/tinybird/client.goindex 98a30905d..b50fd5386 100644--- a/apps/private-location/internal/tinybird/client.go+++ b/apps/private-location/internal/tinybird/client.go@@ -15,6 +15,7 @@ const (DatasourceHTTP = "ping_response__v8"DatasourceTCP = "tcp_response__v0"DatasourceDNS = "dns_response__v0"+ DatasourceICMP = "icmp_response__v0")func getBaseURL() string {diff --git a/apps/private-location/proto/private_location/v1/icmp_monitor.pb.go b/apps/private-location/proto/private_location/v1/icmp_monitor.pb.gonew file mode 100644index 000000000..d842fba5e--- /dev/null+++ b/apps/private-location/proto/private_location/v1/icmp_monitor.pb.go@@ -0,0 +1,183 @@+// Code generated by protoc-gen-go. DO NOT EDIT.+// versions:+// protoc-gen-go v1.36.11+// protoc (unknown)+// source: private_location/v1/icmp_monitor.proto++package v1++import (+ protoreflect "google.golang.org/protobuf/reflect/protoreflect"+ protoimpl "google.golang.org/protobuf/runtime/protoimpl"+ reflect "reflect"+ sync "sync"+ unsafe "unsafe"+)++const (+ // Verify that this generated code is sufficiently up-to-date.+ _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)+ // Verify that runtime/protoimpl is sufficiently up-to-date.+ _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)+)++type ICMPMonitor struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`+ Uri string `protobuf:"bytes,2,opt,name=uri,proto3" json:"uri,omitempty"`+ Timeout int64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`+ DegradedAt *int64 `protobuf:"varint,4,opt,name=degraded_at,json=degradedAt,proto3,oneof" json:"degraded_at,omitempty"`+ Periodicity string `protobuf:"bytes,5,opt,name=periodicity,proto3" json:"periodicity,omitempty"`+ Retry int64 `protobuf:"varint,6,opt,name=retry,proto3" json:"retry,omitempty"`+ OtelConfig *OtelConfig `protobuf:"bytes,20,opt,name=otel_config,json=otelConfig,proto3" json:"otel_config,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *ICMPMonitor) Reset() {+ *x = ICMPMonitor{}+ mi := &file_private_location_v1_icmp_monitor_proto_msgTypes[0]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *ICMPMonitor) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*ICMPMonitor) ProtoMessage() {}++func (x *ICMPMonitor) ProtoReflect() protoreflect.Message {+ mi := &file_private_location_v1_icmp_monitor_proto_msgTypes[0]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use ICMPMonitor.ProtoReflect.Descriptor instead.+func (*ICMPMonitor) Descriptor() ([]byte, []int) {+ return file_private_location_v1_icmp_monitor_proto_rawDescGZIP(), []int{0}+}++func (x *ICMPMonitor) GetId() string {+ if x != nil {+ return x.Id+ }+ return ""+}++func (x *ICMPMonitor) GetUri() string {+ if x != nil {+ return x.Uri+ }+ return ""+}++func (x *ICMPMonitor) GetTimeout() int64 {+ if x != nil {+ return x.Timeout+ }+ return 0+}++func (x *ICMPMonitor) GetDegradedAt() int64 {+ if x != nil && x.DegradedAt != nil {+ return *x.DegradedAt+ }+ return 0+}++func (x *ICMPMonitor) GetPeriodicity() string {+ if x != nil {+ return x.Periodicity+ }+ return ""+}++func (x *ICMPMonitor) GetRetry() int64 {+ if x != nil {+ return x.Retry+ }+ return 0+}++func (x *ICMPMonitor) GetOtelConfig() *OtelConfig {+ if x != nil {+ return x.OtelConfig+ }+ return nil+}++var File_private_location_v1_icmp_monitor_proto protoreflect.FileDescriptor++const file_private_location_v1_icmp_monitor_proto_rawDesc = "" ++ "\n" ++ "&private_location/v1/icmp_monitor.proto\x12\x13private_location.v1\x1a\x1eprivate_location/v1/otel.proto\"\xf9\x01\n" ++ "\vICMPMonitor\x12\x0e\n" ++ "\x02id\x18\x01 \x01(\tR\x02id\x12\x10\n" ++ "\x03uri\x18\x02 \x01(\tR\x03uri\x12\x18\n" ++ "\atimeout\x18\x03 \x01(\x03R\atimeout\x12$\n" ++ "\vdegraded_at\x18\x04 \x01(\x03H\x00R\n" ++ "degradedAt\x88\x01\x01\x12 \n" ++ "\vperiodicity\x18\x05 \x01(\tR\vperiodicity\x12\x14\n" ++ "\x05retry\x18\x06 \x01(\x03R\x05retry\x12@\n" ++ "\votel_config\x18\x14 \x01(\v2\x1f.private_location.v1.OtelConfigR\n" ++ "otelConfigB\x0e\n" ++ "\f_degraded_atBJZHgithub.com/openstatushq/openstatus/packages/proto/private_location/v1;v1b\x06proto3"++var (+ file_private_location_v1_icmp_monitor_proto_rawDescOnce sync.Once+ file_private_location_v1_icmp_monitor_proto_rawDescData []byte+)++func file_private_location_v1_icmp_monitor_proto_rawDescGZIP() []byte {+ file_private_location_v1_icmp_monitor_proto_rawDescOnce.Do(func() {+ file_private_location_v1_icmp_monitor_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_private_location_v1_icmp_monitor_proto_rawDesc), len(file_private_location_v1_icmp_monitor_proto_rawDesc)))+ })+ return file_private_location_v1_icmp_monitor_proto_rawDescData+}++var file_private_location_v1_icmp_monitor_proto_msgTypes = make([]protoimpl.MessageInfo, 1)+var file_private_location_v1_icmp_monitor_proto_goTypes = []any{+ (*ICMPMonitor)(nil), // 0: private_location.v1.ICMPMonitor+ (*OtelConfig)(nil), // 1: private_location.v1.OtelConfig+}+var file_private_location_v1_icmp_monitor_proto_depIdxs = []int32{+ 1, // 0: private_location.v1.ICMPMonitor.otel_config:type_name -> private_location.v1.OtelConfig+ 1, // [1:1] is the sub-list for method output_type+ 1, // [1:1] is the sub-list for method input_type+ 1, // [1:1] is the sub-list for extension type_name+ 1, // [1:1] is the sub-list for extension extendee+ 0, // [0:1] is the sub-list for field type_name+}++func init() { file_private_location_v1_icmp_monitor_proto_init() }+func file_private_location_v1_icmp_monitor_proto_init() {+ if File_private_location_v1_icmp_monitor_proto != nil {+ return+ }+ file_private_location_v1_otel_proto_init()+ file_private_location_v1_icmp_monitor_proto_msgTypes[0].OneofWrappers = []any{}+ type x struct{}+ out := protoimpl.TypeBuilder{+ File: protoimpl.DescBuilder{+ GoPackagePath: reflect.TypeOf(x{}).PkgPath(),+ RawDescriptor: unsafe.Slice(unsafe.StringData(file_private_location_v1_icmp_monitor_proto_rawDesc), len(file_private_location_v1_icmp_monitor_proto_rawDesc)),+ NumEnums: 0,+ NumMessages: 1,+ NumExtensions: 0,+ NumServices: 0,+ },+ GoTypes: file_private_location_v1_icmp_monitor_proto_goTypes,+ DependencyIndexes: file_private_location_v1_icmp_monitor_proto_depIdxs,+ MessageInfos: file_private_location_v1_icmp_monitor_proto_msgTypes,+ }.Build()+ File_private_location_v1_icmp_monitor_proto = out.File+ file_private_location_v1_icmp_monitor_proto_goTypes = nil+ file_private_location_v1_icmp_monitor_proto_depIdxs = nil+}diff --git a/apps/private-location/proto/private_location/v1/private_location.connect.go b/apps/private-location/proto/private_location/v1/private_location.connect.goindex 40235485f..8138ab7c5 100644--- a/apps/private-location/proto/private_location/v1/private_location.connect.go+++ b/apps/private-location/proto/private_location/v1/private_location.connect.go@@ -44,6 +44,9 @@ const (// PrivateLocationServiceIngestDNSProcedure is the fully-qualified name of the// PrivateLocationService's IngestDNS RPC.PrivateLocationServiceIngestDNSProcedure = "/private_location.v1.PrivateLocationService/IngestDNS"+ // PrivateLocationServiceIngestICMPProcedure is the fully-qualified name of the+ // PrivateLocationService's IngestICMP RPC.+ PrivateLocationServiceIngestICMPProcedure = "/private_location.v1.PrivateLocationService/IngestICMP")// PrivateLocationServiceClient is a client for the private_location.v1.PrivateLocationService@@ -53,6 +56,7 @@ type PrivateLocationServiceClient interface {IngestTCP(context.Context, *connect.Request[IngestTCPRequest]) (*connect.Response[IngestTCPResponse], error)IngestHTTP(context.Context, *connect.Request[IngestHTTPRequest]) (*connect.Response[IngestHTTPResponse], error)IngestDNS(context.Context, *connect.Request[IngestDNSRequest]) (*connect.Response[IngestDNSResponse], error)+ IngestICMP(context.Context, *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error)}// NewPrivateLocationServiceClient constructs a client for the@@ -90,6 +94,12 @@ func NewPrivateLocationServiceClient(httpClient connect.HTTPClient, baseURL striconnect.WithSchema(privateLocationServiceMethods.ByName("IngestDNS")),connect.WithClientOptions(opts...),),+ ingestICMP: connect.NewClient[IngestICMPRequest, IngestICMPResponse](+ httpClient,+ baseURL+PrivateLocationServiceIngestICMPProcedure,+ connect.WithSchema(privateLocationServiceMethods.ByName("IngestICMP")),+ connect.WithClientOptions(opts...),+ ),}}@@ -99,6 +109,7 @@ type privateLocationServiceClient struct {ingestTCP *connect.Client[IngestTCPRequest, IngestTCPResponse]ingestHTTP *connect.Client[IngestHTTPRequest, IngestHTTPResponse]ingestDNS *connect.Client[IngestDNSRequest, IngestDNSResponse]+ ingestICMP *connect.Client[IngestICMPRequest, IngestICMPResponse]}// Monitors calls private_location.v1.PrivateLocationService.Monitors.@@ -121,6 +132,11 @@ func (c *privateLocationServiceClient) IngestDNS(ctx context.Context, req *connereturn c.ingestDNS.CallUnary(ctx, req)}+// IngestICMP calls private_location.v1.PrivateLocationService.IngestICMP.+func (c *privateLocationServiceClient) IngestICMP(ctx context.Context, req *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error) {+ return c.ingestICMP.CallUnary(ctx, req)+}+// PrivateLocationServiceHandler is an implementation of the// private_location.v1.PrivateLocationService service.type PrivateLocationServiceHandler interface {@@ -128,6 +144,7 @@ type PrivateLocationServiceHandler interface {IngestTCP(context.Context, *connect.Request[IngestTCPRequest]) (*connect.Response[IngestTCPResponse], error)IngestHTTP(context.Context, *connect.Request[IngestHTTPRequest]) (*connect.Response[IngestHTTPResponse], error)IngestDNS(context.Context, *connect.Request[IngestDNSRequest]) (*connect.Response[IngestDNSResponse], error)+ IngestICMP(context.Context, *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error)}// NewPrivateLocationServiceHandler builds an HTTP handler from the service implementation. It@@ -161,6 +178,12 @@ func NewPrivateLocationServiceHandler(svc PrivateLocationServiceHandler, opts ..connect.WithSchema(privateLocationServiceMethods.ByName("IngestDNS")),connect.WithHandlerOptions(opts...),)+ privateLocationServiceIngestICMPHandler := connect.NewUnaryHandler(+ PrivateLocationServiceIngestICMPProcedure,+ svc.IngestICMP,+ connect.WithSchema(privateLocationServiceMethods.ByName("IngestICMP")),+ connect.WithHandlerOptions(opts...),+ )return "/private_location.v1.PrivateLocationService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {switch r.URL.Path {case PrivateLocationServiceMonitorsProcedure:@@ -171,6 +194,8 @@ func NewPrivateLocationServiceHandler(svc PrivateLocationServiceHandler, opts ..privateLocationServiceIngestHTTPHandler.ServeHTTP(w, r)case PrivateLocationServiceIngestDNSProcedure:privateLocationServiceIngestDNSHandler.ServeHTTP(w, r)+ case PrivateLocationServiceIngestICMPProcedure:+ privateLocationServiceIngestICMPHandler.ServeHTTP(w, r)default:http.NotFound(w, r)}@@ -195,3 +220,7 @@ func (UnimplementedPrivateLocationServiceHandler) IngestHTTP(context.Context, *cfunc (UnimplementedPrivateLocationServiceHandler) IngestDNS(context.Context, *connect.Request[IngestDNSRequest]) (*connect.Response[IngestDNSResponse], error) {return nil, connect.NewError(connect.CodeUnimplemented, errors.New("private_location.v1.PrivateLocationService.IngestDNS is not implemented"))}++func (UnimplementedPrivateLocationServiceHandler) IngestICMP(context.Context, *connect.Request[IngestICMPRequest]) (*connect.Response[IngestICMPResponse], error) {+ return nil, connect.NewError(connect.CodeUnimplemented, errors.New("private_location.v1.PrivateLocationService.IngestICMP is not implemented"))+}diff --git a/apps/private-location/proto/private_location/v1/private_location.pb.go b/apps/private-location/proto/private_location/v1/private_location.pb.goindex e31eb986c..a28112bc7 100644--- a/apps/private-location/proto/private_location/v1/private_location.pb.go+++ b/apps/private-location/proto/private_location/v1/private_location.pb.go@@ -62,6 +62,7 @@ type MonitorsResponse struct {HttpMonitors []*HTTPMonitor `protobuf:"bytes,1,rep,name=http_monitors,json=httpMonitors,proto3" json:"http_monitors,omitempty"`TcpMonitors []*TCPMonitor `protobuf:"bytes,2,rep,name=tcp_monitors,json=tcpMonitors,proto3" json:"tcp_monitors,omitempty"`DnsMonitors []*DNSMonitor `protobuf:"bytes,3,rep,name=dns_monitors,json=dnsMonitors,proto3" json:"dns_monitors,omitempty"`+ IcmpMonitors []*ICMPMonitor `protobuf:"bytes,5,rep,name=icmp_monitors,json=icmpMonitors,proto3" json:"icmp_monitors,omitempty"`Region string `protobuf:"bytes,4,opt,name=region,proto3" json:"region,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache@@ -118,6 +119,13 @@ func (x *MonitorsResponse) GetDnsMonitors() []*DNSMonitor {return nil}+func (x *MonitorsResponse) GetIcmpMonitors() []*ICMPMonitor {+ if x != nil {+ return x.IcmpMonitors+ }+ return nil+}+func (x *MonitorsResponse) GetRegion() string {if x != nil {return x.Region@@ -657,16 +665,201 @@ func (*IngestDNSResponse) Descriptor() ([]byte, []int) {return file_private_location_v1_private_location_proto_rawDescGZIP(), []int{8}}+type IngestICMPRequest struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`+ MonitorId string `protobuf:"bytes,2,opt,name=monitorId,proto3" json:"monitorId,omitempty"`+ Latency int64 `protobuf:"varint,3,opt,name=latency,proto3" json:"latency,omitempty"`+ LatencyMin int64 `protobuf:"varint,4,opt,name=latencyMin,proto3" json:"latencyMin,omitempty"`+ LatencyMax int64 `protobuf:"varint,5,opt,name=latencyMax,proto3" json:"latencyMax,omitempty"`+ PacketsSent int64 `protobuf:"varint,6,opt,name=packetsSent,proto3" json:"packetsSent,omitempty"`+ PacketsReceived int64 `protobuf:"varint,7,opt,name=packetsReceived,proto3" json:"packetsReceived,omitempty"`+ Timestamp int64 `protobuf:"varint,8,opt,name=timestamp,proto3" json:"timestamp,omitempty"`+ CronTimestamp int64 `protobuf:"varint,9,opt,name=cronTimestamp,proto3" json:"cronTimestamp,omitempty"`+ Uri string `protobuf:"bytes,10,opt,name=uri,proto3" json:"uri,omitempty"`+ Message string `protobuf:"bytes,11,opt,name=message,proto3" json:"message,omitempty"`+ RequestStatus string `protobuf:"bytes,12,opt,name=requestStatus,proto3" json:"requestStatus,omitempty"`+ Error int64 `protobuf:"varint,13,opt,name=error,proto3" json:"error,omitempty"`+ Timing string `protobuf:"bytes,14,opt,name=timing,proto3" json:"timing,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *IngestICMPRequest) Reset() {+ *x = IngestICMPRequest{}+ mi := &file_private_location_v1_private_location_proto_msgTypes[9]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *IngestICMPRequest) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*IngestICMPRequest) ProtoMessage() {}++func (x *IngestICMPRequest) ProtoReflect() protoreflect.Message {+ mi := &file_private_location_v1_private_location_proto_msgTypes[9]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use IngestICMPRequest.ProtoReflect.Descriptor instead.+func (*IngestICMPRequest) Descriptor() ([]byte, []int) {+ return file_private_location_v1_private_location_proto_rawDescGZIP(), []int{9}+}++func (x *IngestICMPRequest) GetId() string {+ if x != nil {+ return x.Id+ }+ return ""+}++func (x *IngestICMPRequest) GetMonitorId() string {+ if x != nil {+ return x.MonitorId+ }+ return ""+}++func (x *IngestICMPRequest) GetLatency() int64 {+ if x != nil {+ return x.Latency+ }+ return 0+}++func (x *IngestICMPRequest) GetLatencyMin() int64 {+ if x != nil {+ return x.LatencyMin+ }+ return 0+}++func (x *IngestICMPRequest) GetLatencyMax() int64 {+ if x != nil {+ return x.LatencyMax+ }+ return 0+}++func (x *IngestICMPRequest) GetPacketsSent() int64 {+ if x != nil {+ return x.PacketsSent+ }+ return 0+}++func (x *IngestICMPRequest) GetPacketsReceived() int64 {+ if x != nil {+ return x.PacketsReceived+ }+ return 0+}++func (x *IngestICMPRequest) GetTimestamp() int64 {+ if x != nil {+ return x.Timestamp+ }+ return 0+}++func (x *IngestICMPRequest) GetCronTimestamp() int64 {+ if x != nil {+ return x.CronTimestamp+ }+ return 0+}++func (x *IngestICMPRequest) GetUri() string {+ if x != nil {+ return x.Uri+ }+ return ""+}++func (x *IngestICMPRequest) GetMessage() string {+ if x != nil {+ return x.Message+ }+ return ""+}++func (x *IngestICMPRequest) GetRequestStatus() string {+ if x != nil {+ return x.RequestStatus+ }+ return ""+}++func (x *IngestICMPRequest) GetError() int64 {+ if x != nil {+ return x.Error+ }+ return 0+}++func (x *IngestICMPRequest) GetTiming() string {+ if x != nil {+ return x.Timing+ }+ return ""+}++type IngestICMPResponse struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *IngestICMPResponse) Reset() {+ *x = IngestICMPResponse{}+ mi := &file_private_location_v1_private_location_proto_msgTypes[10]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *IngestICMPResponse) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*IngestICMPResponse) ProtoMessage() {}++func (x *IngestICMPResponse) ProtoReflect() protoreflect.Message {+ mi := &file_private_location_v1_private_location_proto_msgTypes[10]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use IngestICMPResponse.ProtoReflect.Descriptor instead.+func (*IngestICMPResponse) Descriptor() ([]byte, []int) {+ return file_private_location_v1_private_location_proto_rawDescGZIP(), []int{10}+}+var File_private_location_v1_private_location_proto protoreflect.FileDescriptorconst file_private_location_v1_private_location_proto_rawDesc = "" +"\n" +- "*private_location/v1/private_location.proto\x12\x13private_location.v1\x1a%private_location/v1/dns_monitor.proto\x1a&private_location/v1/http_monitor.proto\x1a%private_location/v1/tcp_monitor.proto\"\x11\n" +- "\x0fMonitorsRequest\"\xf9\x01\n" ++ "*private_location/v1/private_location.proto\x12\x13private_location.v1\x1a%private_location/v1/dns_monitor.proto\x1a&private_location/v1/http_monitor.proto\x1a&private_location/v1/icmp_monitor.proto\x1a%private_location/v1/tcp_monitor.proto\"\x11\n" ++ "\x0fMonitorsRequest\"\xc0\x02\n" +"\x10MonitorsResponse\x12E\n" +"\rhttp_monitors\x18\x01 \x03(\v2 .private_location.v1.HTTPMonitorR\fhttpMonitors\x12B\n" +"\ftcp_monitors\x18\x02 \x03(\v2\x1f.private_location.v1.TCPMonitorR\vtcpMonitors\x12B\n" +- "\fdns_monitors\x18\x03 \x03(\v2\x1f.private_location.v1.DNSMonitorR\vdnsMonitors\x12\x16\n" ++ "\fdns_monitors\x18\x03 \x03(\v2\x1f.private_location.v1.DNSMonitorR\vdnsMonitors\x12E\n" ++ "\ricmp_monitors\x18\x05 \x03(\v2 .private_location.v1.ICMPMonitorR\ficmpMonitors\x12\x16\n" +"\x06region\x18\x04 \x01(\tR\x06region\"\x9e\x02\n" +"\x10IngestTCPRequest\x12\x0e\n" +"\x02id\x18\x01 \x01(\tR\x02id\x12\x1c\n" +@@ -717,13 +910,36 @@ const file_private_location_v1_private_location_proto_rawDesc = "" +"\fRecordsEntry\x12\x10\n" +"\x03key\x18\x01 \x01(\tR\x03key\x122\n" +"\x05value\x18\x02 \x01(\v2\x1c.private_location.v1.RecordsR\x05value:\x028\x01\"\x13\n" +- "\x11IngestDNSResponse2\x90\x03\n" ++ "\x11IngestDNSResponse\"\xab\x03\n" ++ "\x11IngestICMPRequest\x12\x0e\n" ++ "\x02id\x18\x01 \x01(\tR\x02id\x12\x1c\n" ++ "\tmonitorId\x18\x02 \x01(\tR\tmonitorId\x12\x18\n" ++ "\alatency\x18\x03 \x01(\x03R\alatency\x12\x1e\n" ++ "\n" ++ "latencyMin\x18\x04 \x01(\x03R\n" ++ "latencyMin\x12\x1e\n" ++ "\n" ++ "latencyMax\x18\x05 \x01(\x03R\n" ++ "latencyMax\x12 \n" ++ "\vpacketsSent\x18\x06 \x01(\x03R\vpacketsSent\x12(\n" ++ "\x0fpacketsReceived\x18\a \x01(\x03R\x0fpacketsReceived\x12\x1c\n" ++ "\ttimestamp\x18\b \x01(\x03R\ttimestamp\x12$\n" ++ "\rcronTimestamp\x18\t \x01(\x03R\rcronTimestamp\x12\x10\n" ++ "\x03uri\x18\n" ++ " \x01(\tR\x03uri\x12\x18\n" ++ "\amessage\x18\v \x01(\tR\amessage\x12$\n" ++ "\rrequestStatus\x18\f \x01(\tR\rrequestStatus\x12\x14\n" ++ "\x05error\x18\r \x01(\x03R\x05error\x12\x16\n" ++ "\x06timing\x18\x0e \x01(\tR\x06timing\"\x14\n" ++ "\x12IngestICMPResponse2\xf1\x03\n" +"\x16PrivateLocationService\x12Y\n" +"\bMonitors\x12$.private_location.v1.MonitorsRequest\x1a%.private_location.v1.MonitorsResponse\"\x00\x12\\\n" +"\tIngestTCP\x12%.private_location.v1.IngestTCPRequest\x1a&.private_location.v1.IngestTCPResponse\"\x00\x12_\n" +"\n" +"IngestHTTP\x12&.private_location.v1.IngestHTTPRequest\x1a'.private_location.v1.IngestHTTPResponse\"\x00\x12\\\n" +- "\tIngestDNS\x12%.private_location.v1.IngestDNSRequest\x1a&.private_location.v1.IngestDNSResponse\"\x00BJZHgithub.com/openstatushq/openstatus/packages/proto/private_location/v1;v1b\x06proto3"+ "\tIngestDNS\x12%.private_location.v1.IngestDNSRequest\x1a&.private_location.v1.IngestDNSResponse\"\x00\x12_\n" ++ "\n" ++ "IngestICMP\x12&.private_location.v1.IngestICMPRequest\x1a'.private_location.v1.IngestICMPResponse\"\x00BJZHgithub.com/openstatushq/openstatus/packages/proto/private_location/v1;v1b\x06proto3"var (file_private_location_v1_private_location_proto_rawDescOnce sync.Once@@ -737,7 +953,7 @@ func file_private_location_v1_private_location_proto_rawDescGZIP() []byte {return file_private_location_v1_private_location_proto_rawDescData}-var file_private_location_v1_private_location_proto_msgTypes = make([]protoimpl.MessageInfo, 10)+var file_private_location_v1_private_location_proto_msgTypes = make([]protoimpl.MessageInfo, 12)var file_private_location_v1_private_location_proto_goTypes = []any{(*MonitorsRequest)(nil), // 0: private_location.v1.MonitorsRequest(*MonitorsResponse)(nil), // 1: private_location.v1.MonitorsResponse@@ -748,30 +964,36 @@ var file_private_location_v1_private_location_proto_goTypes = []any{(*Records)(nil), // 6: private_location.v1.Records(*IngestDNSRequest)(nil), // 7: private_location.v1.IngestDNSRequest(*IngestDNSResponse)(nil), // 8: private_location.v1.IngestDNSResponse- nil, // 9: private_location.v1.IngestDNSRequest.RecordsEntry- (*HTTPMonitor)(nil), // 10: private_location.v1.HTTPMonitor- (*TCPMonitor)(nil), // 11: private_location.v1.TCPMonitor- (*DNSMonitor)(nil), // 12: private_location.v1.DNSMonitor+ (*IngestICMPRequest)(nil), // 9: private_location.v1.IngestICMPRequest+ (*IngestICMPResponse)(nil), // 10: private_location.v1.IngestICMPResponse+ nil, // 11: private_location.v1.IngestDNSRequest.RecordsEntry+ (*HTTPMonitor)(nil), // 12: private_location.v1.HTTPMonitor+ (*TCPMonitor)(nil), // 13: private_location.v1.TCPMonitor+ (*DNSMonitor)(nil), // 14: private_location.v1.DNSMonitor+ (*ICMPMonitor)(nil), // 15: private_location.v1.ICMPMonitor}var file_private_location_v1_private_location_proto_depIdxs = []int32{- 10, // 0: private_location.v1.MonitorsResponse.http_monitors:type_name -> private_location.v1.HTTPMonitor- 11, // 1: private_location.v1.MonitorsResponse.tcp_monitors:type_name -> private_location.v1.TCPMonitor- 12, // 2: private_location.v1.MonitorsResponse.dns_monitors:type_name -> private_location.v1.DNSMonitor- 9, // 3: private_location.v1.IngestDNSRequest.records:type_name -> private_location.v1.IngestDNSRequest.RecordsEntry- 6, // 4: private_location.v1.IngestDNSRequest.RecordsEntry.value:type_name -> private_location.v1.Records- 0, // 5: private_location.v1.PrivateLocationService.Monitors:input_type -> private_location.v1.MonitorsRequest- 2, // 6: private_location.v1.PrivateLocationService.IngestTCP:input_type -> private_location.v1.IngestTCPRequest- 4, // 7: private_location.v1.PrivateLocationService.IngestHTTP:input_type -> private_location.v1.IngestHTTPRequest- 7, // 8: private_location.v1.PrivateLocationService.IngestDNS:input_type -> private_location.v1.IngestDNSRequest- 1, // 9: private_location.v1.PrivateLocationService.Monitors:output_type -> private_location.v1.MonitorsResponse- 3, // 10: private_location.v1.PrivateLocationService.IngestTCP:output_type -> private_location.v1.IngestTCPResponse- 5, // 11: private_location.v1.PrivateLocationService.IngestHTTP:output_type -> private_location.v1.IngestHTTPResponse- 8, // 12: private_location.v1.PrivateLocationService.IngestDNS:output_type -> private_location.v1.IngestDNSResponse- 9, // [9:13] is the sub-list for method output_type- 5, // [5:9] is the sub-list for method input_type- 5, // [5:5] is the sub-list for extension type_name- 5, // [5:5] is the sub-list for extension extendee- 0, // [0:5] is the sub-list for field type_name+ 12, // 0: private_location.v1.MonitorsResponse.http_monitors:type_name -> private_location.v1.HTTPMonitor+ 13, // 1: private_location.v1.MonitorsResponse.tcp_monitors:type_name -> private_location.v1.TCPMonitor+ 14, // 2: private_location.v1.MonitorsResponse.dns_monitors:type_name -> private_location.v1.DNSMonitor+ 15, // 3: private_location.v1.MonitorsResponse.icmp_monitors:type_name -> private_location.v1.ICMPMonitor+ 11, // 4: private_location.v1.IngestDNSRequest.records:type_name -> private_location.v1.IngestDNSRequest.RecordsEntry+ 6, // 5: private_location.v1.IngestDNSRequest.RecordsEntry.value:type_name -> private_location.v1.Records+ 0, // 6: private_location.v1.PrivateLocationService.Monitors:input_type -> private_location.v1.MonitorsRequest+ 2, // 7: private_location.v1.PrivateLocationService.IngestTCP:input_type -> private_location.v1.IngestTCPRequest+ 4, // 8: private_location.v1.PrivateLocationService.IngestHTTP:input_type -> private_location.v1.IngestHTTPRequest+ 7, // 9: private_location.v1.PrivateLocationService.IngestDNS:input_type -> private_location.v1.IngestDNSRequest+ 9, // 10: private_location.v1.PrivateLocationService.IngestICMP:input_type -> private_location.v1.IngestICMPRequest+ 1, // 11: private_location.v1.PrivateLocationService.Monitors:output_type -> private_location.v1.MonitorsResponse+ 3, // 12: private_location.v1.PrivateLocationService.IngestTCP:output_type -> private_location.v1.IngestTCPResponse+ 5, // 13: private_location.v1.PrivateLocationService.IngestHTTP:output_type -> private_location.v1.IngestHTTPResponse+ 8, // 14: private_location.v1.PrivateLocationService.IngestDNS:output_type -> private_location.v1.IngestDNSResponse+ 10, // 15: private_location.v1.PrivateLocationService.IngestICMP:output_type -> private_location.v1.IngestICMPResponse+ 11, // [11:16] is the sub-list for method output_type+ 6, // [6:11] is the sub-list for method input_type+ 6, // [6:6] is the sub-list for extension type_name+ 6, // [6:6] is the sub-list for extension extendee+ 0, // [0:6] is the sub-list for field type_name}func init() { file_private_location_v1_private_location_proto_init() }@@ -781,6 +1003,7 @@ func file_private_location_v1_private_location_proto_init() {}file_private_location_v1_dns_monitor_proto_init()file_private_location_v1_http_monitor_proto_init()+ file_private_location_v1_icmp_monitor_proto_init()file_private_location_v1_tcp_monitor_proto_init()type x struct{}out := protoimpl.TypeBuilder{@@ -788,7 +1011,7 @@ func file_private_location_v1_private_location_proto_init() {GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: unsafe.Slice(unsafe.StringData(file_private_location_v1_private_location_proto_rawDesc), len(file_private_location_v1_private_location_proto_rawDesc)),NumEnums: 0,- NumMessages: 10,+ NumMessages: 12,NumExtensions: 0,NumServices: 1,},diff --git a/apps/server/src/libs/checker/utils.test.ts b/apps/server/src/libs/checker/utils.test.tsnew file mode 100644index 000000000..aa41d39e1--- /dev/null+++ b/apps/server/src/libs/checker/utils.test.ts@@ -0,0 +1,119 @@+import type { z } from "@hono/zod-openapi";+import type { selectMonitorSchema } from "@openstatus/db/src/schema";+import { expect, test } from "@openstatus/test-utils";++import { OpenStatusApiError } from "@/libs/errors";++import { getCheckerPayload, getCheckerUrl } from "./utils";++type Monitor = z.infer<typeof selectMonitorSchema>;++function buildMonitor(overrides: Partial<Monitor> = {}): Monitor {+ return {+ id: 1,+ workspaceId: 1,+ jobType: "http",+ active: true,+ public: false,+ name: "test",+ description: "",+ url: "https://example.openstatus.dev",+ method: "GET",+ body: "",+ headers: [],+ assertions: null,+ periodicity: "10m",+ regions: ["ams"],+ timeout: 30_000,+ degradedAfter: null,+ retry: 3,+ followRedirects: true,+ otelEndpoint: null,+ otelHeaders: null,+ status: "active",+ createdAt: null,+ updatedAt: null,+ deletedAt: null,+ ...overrides,+ } as Monitor;+}++test("getCheckerUrl routes each job type to its own checker endpoint", () => {+ for (const jobType of ["http", "tcp", "dns", "icmp"] as const) {+ const url = getCheckerUrl(buildMonitor({ jobType }));+ expect(url).toContain(`/checker/${jobType}?`);+ expect(url).toContain("monitor_id=1");+ }+});++test("getCheckerUrl rejects an unsupported job type", () => {+ expect(() =>+ getCheckerUrl(buildMonitor({ jobType: "unknown" as Monitor["jobType"] })),+ ).toThrow(OpenStatusApiError);+});++test("getCheckerPayload builds an ICMP payload without assertions", () => {+ const payload = getCheckerPayload(+ buildMonitor({+ jobType: "icmp",+ url: "1.1.1.1",+ // Assertions are meaningless for ICMP and must not leak into the payload+ // even when the row still carries some from an earlier job type.+ assertions:+ '[{"version":"v1","type":"status","compare":"eq","target":200}]',+ }),+ "active",+ );++ expect(payload).toMatchObject({+ uri: "1.1.1.1",+ monitorId: "1",+ workspaceId: "1",+ status: "active",+ trigger: "api",+ timeout: 30_000,+ });+ expect("assertions" in payload).toBe(false);+ expect("url" in payload).toBe(false);+});++test("getCheckerPayload builds a DNS payload with assertions", () => {+ const payload = getCheckerPayload(+ buildMonitor({+ jobType: "dns",+ url: "openstatus.dev",+ assertions:+ '[{"version":"v1","type":"dnsRecord","record":"A","compare":"eq","target":"1.2.3.4"}]',+ }),+ "active",+ );++ expect(payload).toMatchObject({ uri: "openstatus.dev", trigger: "api" });+ expect("assertions" in payload).toBe(true);+});++test("getCheckerPayload forwards the OTel config when configured", () => {+ const payload = getCheckerPayload(+ buildMonitor({+ jobType: "icmp",+ url: "1.1.1.1",+ otelEndpoint: "https://otel.example.com:4318",+ otelHeaders: [{ key: "Authorization", value: "Basic dGVzdA==" }],+ }),+ "active",+ );++ expect(payload.otelConfig).toEqual({+ endpoint: "https://otel.example.com:4318",+ headers: { Authorization: "Basic dGVzdA==" },+ });+});++test("getCheckerPayload rejects an unsupported job type", () => {+ expect(() =>+ getCheckerPayload(+ buildMonitor({ jobType: "unknown" as Monitor["jobType"] }),+ "active",+ ),+ ).toThrow(OpenStatusApiError);+});diff --git a/apps/server/src/libs/checker/utils.ts b/apps/server/src/libs/checker/utils.tsindex 01748d183..5e411a20f 100644--- a/apps/server/src/libs/checker/utils.ts+++ b/apps/server/src/libs/checker/utils.ts@@ -1,7 +1,9 @@import type { z } from "@hono/zod-openapi";import type { selectMonitorSchema } from "@openstatus/db/src/schema";import {+ type DNSPayloadSchema,type httpPayloadSchema,+ type icmpPayloadSchema,type tpcPayloadSchema,transformHeaders,} from "@openstatus/utils";@@ -11,7 +13,11 @@ import { OpenStatusApiError } from "@/libs/errors";export function getCheckerPayload(monitor: z.infer<typeof selectMonitorSchema>,status: z.infer<typeof selectMonitorSchema>["status"],-): z.infer<typeof httpPayloadSchema> | z.infer<typeof tpcPayloadSchema> {+):+ | z.infer<typeof httpPayloadSchema>+ | z.infer<typeof tpcPayloadSchema>+ | z.infer<typeof DNSPayloadSchema>+ | z.infer<typeof icmpPayloadSchema> {const timestamp = new Date().getTime();switch (monitor.jobType) {case "http":@@ -57,11 +63,48 @@ export function getCheckerPayload(retry: monitor.retry ?? 0,followRedirects: monitor.followRedirects ?? false,};+ case "dns":+ return {+ workspaceId: String(monitor.workspaceId),+ monitorId: String(monitor.id),+ uri: monitor.url,+ status: status,+ assertions: monitor.assertions ? JSON.parse(monitor.assertions) : null,+ cronTimestamp: timestamp,+ degradedAfter: monitor.degradedAfter,+ timeout: monitor.timeout,+ trigger: "api",+ otelConfig: monitor.otelEndpoint+ ? {+ endpoint: monitor.otelEndpoint,+ headers: transformHeaders(monitor.otelHeaders),+ }+ : undefined,+ retry: monitor.retry ?? 0,+ };+ case "icmp":+ // No assertions: an ICMP check only reports reachability and latency.+ return {+ workspaceId: String(monitor.workspaceId),+ monitorId: String(monitor.id),+ uri: monitor.url,+ status: status,+ cronTimestamp: timestamp,+ degradedAfter: monitor.degradedAfter,+ timeout: monitor.timeout,+ trigger: "api",+ otelConfig: monitor.otelEndpoint+ ? {+ endpoint: monitor.otelEndpoint,+ headers: transformHeaders(monitor.otelHeaders),+ }+ : undefined,+ retry: monitor.retry ?? 0,+ };default:throw new OpenStatusApiError({code: "BAD_REQUEST",- message:- "Invalid jobType, currently only 'http' and 'tcp' are supported",+ message: `Invalid jobType '${monitor.jobType}'`,});}}@@ -83,14 +126,14 @@ export function getCheckerUrl(): string {switch (monitor.jobType) {case "http":- return `https://openstatus-checker.fly.dev/checker/http?monitor_id=${monitor.id}&trigger=${opts.trigger}&data=${opts.data}`;case "tcp":- return `https://openstatus-checker.fly.dev/checker/tcp?monitor_id=${monitor.id}&trigger=${opts.trigger}&data=${opts.data}`;+ case "dns":+ case "icmp":+ return `https://openstatus-checker.fly.dev/checker/${monitor.jobType}?monitor_id=${monitor.id}&trigger=${opts.trigger}&data=${opts.data}`;default:throw new OpenStatusApiError({code: "BAD_REQUEST",- message:- "Invalid jobType, currently only 'http' and 'tcp' are supported",+ message: `Invalid jobType '${monitor.jobType}'`,});}}diff --git a/apps/server/src/routes/rpc/handlers/monitor/__tests__/monitor.test.ts b/apps/server/src/routes/rpc/handlers/monitor/__tests__/monitor.test.tsindex 91b33ac27..833685d72 100644--- a/apps/server/src/routes/rpc/handlers/monitor/__tests__/monitor.test.ts+++ b/apps/server/src/routes/rpc/handlers/monitor/__tests__/monitor.test.ts@@ -7,6 +7,7 @@ import {privateLocationToMonitors,workspace,} from "@openstatus/db/src/schema";+import { monitorRun } from "@openstatus/db/src/schema/monitor_run/monitor_run";import { monitorStatusTable } from "@openstatus/db/src/schema/monitor_status/monitor_status";import { createTestWorkspace } from "@openstatus/db/src/test/factories";import {@@ -48,6 +49,7 @@ let FREE_PLAN_KEY: string;let testHttpMonitorId: number;let testTcpMonitorId: number;let testDnsMonitorId: number;+let testIcmpMonitorId: number;let testMonitorToDeleteId: number;let testMonitorWithStatusId: number;@@ -119,6 +121,7 @@ beforeAll(async () => {await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-http`));await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-tcp`));await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-dns`));+ await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-icmp`));await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-to-delete`));await db.delete(monitor)@@ -190,6 +193,23 @@ beforeAll(async () => {.get();testDnsMonitorId = dnsMon.id;+ // Create test ICMP monitor+ const icmpMon = await db+ .insert(monitor)+ .values({+ workspaceId: 1,+ name: `${TEST_PREFIX}-icmp`,+ url: "1.1.1.1",+ periodicity: "10m",+ active: true,+ regions: "ams",+ jobType: "icmp",+ timeout: 5000,+ })+ .returning()+ .get();+ testIcmpMonitorId = icmpMon.id;+// Create monitor to be deletedconst deleteMon = await db.insert(monitor)@@ -241,6 +261,7 @@ afterAll(async () => {await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-http`));await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-tcp`));await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-dns`));+ await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-icmp`));await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-to-delete`));await db.delete(monitor)@@ -343,6 +364,28 @@ describe("MonitorService.ListMonitors", () => {expect(dnsMon.recordAssertions).toBeDefined();});+ test("returns ICMP monitors with correct structure", async () => {+ const res = await connectRequest(+ "ListMonitors",+ { limit: 100 },+ {+ "x-openstatus-key": "1",+ },+ );++ expect(res.status).toBe(200);++ const data = await res.json();+ const icmpMonitors = data.icmpMonitors || [];+ const icmpMon = icmpMonitors.find(+ (m: { id: string }) => m.id === String(testIcmpMonitorId),+ );++ expect(icmpMon).toBeDefined();+ expect(icmpMon.uri).toBe("1.1.1.1");+ expect(icmpMon.periodicity).toBe("PERIODICITY_10M");+ });+test("returns 401 when no auth key provided", async () => {const res = await connectRequest("ListMonitors", {});@@ -363,7 +406,8 @@ describe("MonitorService.ListMonitors", () => {const totalMonitors =(data.httpMonitors?.length || 0) +(data.tcpMonitors?.length || 0) +- (data.dnsMonitors?.length || 0);+ (data.dnsMonitors?.length || 0) ++ (data.icmpMonitors?.length || 0);// Should return at most 2 monitors totalexpect(totalMonitors).toBeLessThanOrEqual(2);@@ -842,6 +886,53 @@ describe("MonitorService.CreateDNSMonitor", () => {});});+describe("MonitorService.CreateICMPMonitor", () => {+ test("successfully creates ICMP monitor", async () => {+ const res = await connectRequest(+ "CreateICMPMonitor",+ {+ monitor: {+ name: "test-create-icmp",+ uri: "8.8.8.8",+ periodicity: "PERIODICITY_5M",+ timeout: "5000",+ },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);++ const data = await res.json();+ expect(data.monitor).toBeDefined();+ expect(data.monitor.uri).toBe("8.8.8.8");+ expect(data.monitor.periodicity).toBe("PERIODICITY_5M");++ // The row must carry the icmp job type so the cron dispatches a ping.+ const row = await db+ .select()+ .from(monitor)+ .where(eq(monitor.id, Number(data.monitor.id)))+ .get();+ expect(row?.jobType).toBe("icmp");++ // Clean up+ if (data.monitor.id) {+ await db.delete(monitor).where(eq(monitor.id, Number(data.monitor.id)));+ }+ });++ test("returns error when monitor is missing", async () => {+ const res = await connectRequest(+ "CreateICMPMonitor",+ {},+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });+});+describe("MonitorService.UpdateHTTPMonitor", () => {test("successfully updates HTTP monitor with partial data", async () => {const res = await connectRequest(@@ -1343,6 +1434,212 @@ describe("MonitorService.UpdateDNSMonitor", () => {});});+describe("MonitorService.UpdateICMPMonitor", () => {+ test("successfully updates ICMP monitor with partial data", async () => {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ monitor: {+ name: "updated-icmp-name",+ },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);++ const data = await res.json();+ expect(data.monitor).toBeDefined();+ expect(data.monitor.name).toBe("updated-icmp-name");+ // Original URI should be preserved+ expect(data.monitor.uri).toBe("1.1.1.1");++ // Restore original name+ await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ monitor: {+ name: `${TEST_PREFIX}-icmp`,+ },+ },+ { "x-openstatus-key": "1" },+ );+ });++ test("successfully updates ICMP monitor URI", async () => {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ monitor: {+ uri: "9.9.9.9",+ },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);++ const data = await res.json();+ expect(data.monitor.uri).toBe("9.9.9.9");++ // Restore original URI+ await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ monitor: {+ uri: "1.1.1.1",+ },+ },+ { "x-openstatus-key": "1" },+ );+ });++ test("leaves active untouched when the patch omits it", async () => {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ monitor: { name: `${TEST_PREFIX}-icmp` },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);++ const data = await res.json();+ expect(data.monitor.active).toBe(true);+ });++ test("returns current monitor when no monitor data provided", async () => {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);++ const data = await res.json();+ expect(data.monitor).toBeDefined();+ expect(data.monitor.id).toBe(String(testIcmpMonitorId));+ });++ test("returns 404 for non-existent monitor", async () => {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: "99999",+ monitor: { name: "test" },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(404);+ });++ test("returns error when trying to update HTTP monitor as ICMP", async () => {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testHttpMonitorId),+ monitor: { name: "test" },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ const data = await res.json();+ expect(data.message).toContain("type mismatch");+ });++ test("returns 401 when no auth key provided", async () => {+ const res = await connectRequest("UpdateICMPMonitor", {+ id: String(testIcmpMonitorId),+ monitor: { name: "test" },+ });++ expect(res.status).toBe(401);+ });++ // This method is in SKIP_VALIDATION_METHODS, so protovalidate never sees the+ // patch — the bounds it would have applied are enforced in the handler, and+ // nothing downstream re-checks them.+ test("enforces the proto bounds the validation interceptor skips", async () => {+ for (const [field, monitor] of [+ ["retry above max", { retry: "11" }],+ ["negative retry", { retry: "-1" }],+ ["timeout above max", { timeout: "120001" }],+ ["degradedAt above max", { degradedAt: "120001" }],+ ["over-long description", { description: "d".repeat(1025) }],+ ["over-long name", { name: "n".repeat(257) }],+ ["over-long uri", { uri: "u".repeat(2049) }],+ ] as const) {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ { id: String(testIcmpMonitorId), monitor },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ }+ });++ test("leaves the stored monitor untouched when a patch is rejected", async () => {+ const before = await db+ .select()+ .from(monitor)+ .where(eq(monitor.id, testIcmpMonitorId))+ .get();++ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ // A valid name alongside an out-of-range retry: the whole patch must be+ // refused, not partially applied.+ monitor: { name: "should-not-be-written", retry: "99" },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);++ const after = await db+ .select()+ .from(monitor)+ .where(eq(monitor.id, testIcmpMonitorId))+ .get();+ expect(after?.name).toBe(before?.name);+ expect(after?.retry).toBe(before?.retry);+ });++ test("still accepts values at the documented limits", async () => {+ const res = await connectRequest(+ "UpdateICMPMonitor",+ {+ id: String(testIcmpMonitorId),+ monitor: { retry: "10", timeout: "120000" },+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);++ // Restore+ await connectRequest(+ "UpdateICMPMonitor",+ { id: String(testIcmpMonitorId), monitor: { timeout: "5000" } },+ { "x-openstatus-key": "1" },+ );+ });+});+describe("MonitorService - private and internal URLs", () => {// Valid URIs, so protovalidate passes them through to the service guard.const BLOCKED = [@@ -1450,6 +1747,47 @@ describe("MonitorService.TriggerMonitor", () => {expect(res.status).toBe(401);});++ test("dispatches an ICMP monitor to the icmp checker endpoint", async () => {+ // A throwaway monitor: triggering records a monitorRun that references it,+ // and the suite's afterAll deletes monitors without clearing runs.+ const icmpMon = await createMonitor(1, {+ name: `${TEST_PREFIX}-icmp-trigger`,+ url: "1.1.1.1",+ jobType: "icmp",+ periodicity: "10m",+ active: true,+ regions: "ams",+ });++ // Scoped to this test so the surrounding suite keeps the real fetch.+ const realFetch = globalThis.fetch;+ const calls: { url: string; body: string }[] = [];+ globalThis.fetch = ((url: string | URL | Request, init?: RequestInit) => {+ calls.push({ url: String(url), body: String(init?.body ?? "") });+ return Promise.resolve(new Response(null, { status: 200 }));+ }) as typeof fetch;++ try {+ const res = await connectRequest(+ "TriggerMonitor",+ { id: String(icmpMon.id) },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ expect(calls.length).toBeGreaterThan(0);+ expect(calls[0].url).toContain("/checker/icmp?");+ expect(JSON.parse(calls[0].body)).toMatchObject({+ uri: "1.1.1.1",+ monitorId: String(icmpMon.id),+ });+ } finally {+ globalThis.fetch = realFetch;+ await db.delete(monitorRun).where(eq(monitorRun.monitorId, icmpMon.id));+ await db.delete(monitor).where(eq(monitor.id, icmpMon.id));+ }+ });});describe("MonitorService - Authentication", () => {@@ -2522,17 +2860,21 @@ describe("MonitorService.GetMonitor", () => {});describe("MonitorService - Private Locations", () => {- async function seedMonitorWithPrivateLocation(suffix: string) {+ async function seedMonitorWithPrivateLocation(+ suffix: string,+ jobType: "http" | "icmp" = "http",+ ) {const mon = await db.insert(monitor).values({workspaceId: 1,name: `${TEST_PREFIX}-pl-${suffix}`,- url: `https://pl-${suffix}.example.com`,+ url:+ jobType === "icmp" ? "1.1.1.1" : `https://pl-${suffix}.example.com`,periodicity: "1m",active: true,regions: "ams",- jobType: "http",+ jobType,}).returning().get();@@ -2621,6 +2963,50 @@ describe("MonitorService - Private Locations", () => {}});+ test("GetMonitor returns the attached private location id for ICMP", async () => {+ const { mon, pl } = await seedMonitorWithPrivateLocation(+ "get-icmp",+ "icmp",+ );+ try {+ const res = await connectRequest(+ "GetMonitor",+ { id: String(mon.id) },+ { "x-openstatus-key": "1" },+ );+ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.monitor.icmp.privateLocationIds).toEqual([String(pl.id)]);+ } finally {+ await cleanupMonitorWithPrivateLocation(mon.id, pl.id);+ }+ });++ test("ListMonitors returns private_location_ids for ICMP monitors", async () => {+ const { mon, pl } = await seedMonitorWithPrivateLocation(+ "list-icmp",+ "icmp",+ );+ try {+ const res = await connectRequest(+ "ListMonitors",+ { limit: 100 },+ { "x-openstatus-key": "1" },+ );+ expect(res.status).toBe(200);+ const data = await res.json();+ const icmpMonitors = (data.icmpMonitors ?? []) as Array<{+ id: string;+ privateLocationIds?: string[];+ }>;++ const attached = icmpMonitors.find((m) => m.id === String(mon.id));+ expect(attached?.privateLocationIds).toEqual([String(pl.id)]);+ } finally {+ await cleanupMonitorWithPrivateLocation(mon.id, pl.id);+ }+ });+test("UpdateHTTPMonitor keeps the attached private location id", async () => {const { mon, pl } = await seedMonitorWithPrivateLocation("update");try {diff --git a/apps/server/src/routes/rpc/handlers/monitor/converters/index.ts b/apps/server/src/routes/rpc/handlers/monitor/converters/index.tsindex dffcab836..be77f8d61 100644--- a/apps/server/src/routes/rpc/handlers/monitor/converters/index.ts+++ b/apps/server/src/routes/rpc/handlers/monitor/converters/index.ts@@ -47,6 +47,7 @@ export {dbMonitorToHttpProto,dbMonitorToTcpProto,dbMonitorToDnsProto,+ dbMonitorToIcmpProto,} from "./monitors";// Regionsdiff --git a/apps/server/src/routes/rpc/handlers/monitor/converters/monitors.ts b/apps/server/src/routes/rpc/handlers/monitor/converters/monitors.tsindex a7cc9a330..b8aba3d09 100644--- a/apps/server/src/routes/rpc/handlers/monitor/converters/monitors.ts+++ b/apps/server/src/routes/rpc/handlers/monitor/converters/monitors.ts@@ -2,6 +2,7 @@ import type { Monitor } from "@openstatus/db/src/schema/monitors/validation";import type {DNSMonitor,HTTPMonitor,+ ICMPMonitor,TCPMonitor,} from "@openstatus/proto/monitor/v1";@@ -76,6 +77,32 @@ export function dbMonitorToTcpProto(};}+/**+ * Transform database ICMP monitor to proto ICMPMonitor.+ */+export function dbMonitorToIcmpProto(+ dbMon: Monitor,+ privateLocationIds: string[] = [],+): ICMPMonitor {+ return {+ $typeName: "openstatus.monitor.v1.ICMPMonitor",+ id: String(dbMon.id),+ name: dbMon.name,+ uri: dbMon.url,+ periodicity: stringToPeriodicity(dbMon.periodicity),+ timeout: BigInt(dbMon.timeout),+ degradedAt: dbMon.degradedAfter ? BigInt(dbMon.degradedAfter) : undefined,+ retry: BigInt(dbMon.retry ?? MONITOR_DEFAULTS.retry),+ description: dbMon.description,+ active: dbMon.active ?? MONITOR_DEFAULTS.active,+ public: dbMon.public ?? MONITOR_DEFAULTS.public,+ regions: stringsToRegions(dbMon.regions),+ openTelemetry: parseOpenTelemetry(dbMon.otelEndpoint, dbMon.otelHeaders),+ status: stringToMonitorStatus(dbMon.status),+ privateLocationIds,+ };+}+/*** Transform database DNS monitor to proto DNSMonitor.*/diff --git a/apps/server/src/routes/rpc/handlers/monitor/index.ts b/apps/server/src/routes/rpc/handlers/monitor/index.tsindex 351ab90ef..5967421b9 100644--- a/apps/server/src/routes/rpc/handlers/monitor/index.ts+++ b/apps/server/src/routes/rpc/handlers/monitor/index.ts@@ -8,6 +8,7 @@ import type {GetMonitorSummaryResponse,HTTPMonitor,HTTPResponseLogPagination,+ ICMPMonitor,ListMonitorHTTPResponseLogsResponse,MonitorConfig,MonitorService,@@ -47,6 +48,7 @@ import {MONITOR_DEFAULTS,dbMonitorToDnsProto,dbMonitorToHttpProto,+ dbMonitorToIcmpProto,dbMonitorToTcpProto,protoDnsAssertionsToService,protoHeadersToService,@@ -79,6 +81,7 @@ import {getCommonUpdateInput,toValidMethod,validateCommonMonitorFields,+ validateMonitorPatchBounds,} from "./validators";/**@@ -107,7 +110,7 @@ type DBMonitor = NonNullable<Awaited<ReturnType<typeof getMonitorById>>>;async function validateAndGetMonitor(id: string | undefined,workspaceId: number,- expectedJobType: "http" | "tcp" | "dns",+ expectedJobType: "http" | "tcp" | "dns" | "icmp",): Promise<DBMonitor> {if (!id || id.trim() === "") {throw monitorIdRequiredError();@@ -264,6 +267,42 @@ export const monitorServiceImpl: ServiceImpl<typeof MonitorService> = {}},+ async createICMPMonitor(req, ctx) {+ const rpcCtx = getRpcContext(ctx);+ const workspaceId = rpcCtx.workspace.id;+ const limits = rpcCtx.workspace.limits;++ if (!req.monitor) {+ throw monitorRequiredError();+ }++ const mon = req.monitor;++ // Validate required fields (proto validation handles name, uri, periodicity)+ validateCommonMonitorFields(mon);++ // Check workspace limits+ await checkMonitorLimits(workspaceId, limits, mon.periodicity, mon.regions);++ try {+ const created = await createMonitor({+ ctx: toServiceCtx(rpcCtx),+ input: {+ ...getCommonCreateInput(mon),+ jobType: "icmp",+ url: mon.uri,+ method: "GET",+ headers: [],+ assertions: [],+ },+ });++ return { monitor: dbMonitorToIcmpProto(created) };+ } catch (err) {+ toConnectError(err);+ }+ },+async updateHTTPMonitor(req, ctx) {const rpcCtx = getRpcContext(ctx);const workspaceId = rpcCtx.workspace.id;@@ -445,6 +484,58 @@ export const monitorServiceImpl: ServiceImpl<typeof MonitorService> = {);},+ async updateICMPMonitor(req, ctx) {+ const rpcCtx = getRpcContext(ctx);+ const workspaceId = rpcCtx.workspace.id;+ const limits = rpcCtx.workspace.limits;++ const dbMon = await validateAndGetMonitor(req.id, workspaceId, "icmp");++ const plMap = await getPrivateLocationIdsByMonitor({+ ctx: toServiceCtx(rpcCtx),+ input: { monitorIds: [dbMon.id] },+ });+ const privateLocationIds = plMap.get(dbMon.id) ?? [];++ // If no monitor data provided, return current monitor+ if (!req.monitor) {+ const parsed = selectMonitorSchema.safeParse(dbMon);+ if (!parsed.success) {+ throw monitorParseFailedError(req.id);+ }+ return {+ monitor: dbMonitorToIcmpProto(parsed.data, privateLocationIds),+ };+ }++ const mon = req.monitor;++ // Validate regions if provided+ validateCommonMonitorFields(mon);+ // This method skips the protovalidate interceptor (see SKIP_VALIDATION_METHODS),+ // so the message's own bounds have to be applied here.+ validateMonitorPatchBounds(mon);++ // Check workspace limits if periodicity or regions are changing+ checkMonitorConfigLimits(+ limits,+ mon.periodicity || undefined,+ mon.regions && mon.regions.length > 0 ? mon.regions : undefined,+ );++ // Build update values - only include fields that are provided+ const updateValues = getCommonUpdateInput(mon);++ // Handle ICMP-specific fields+ if (mon.uri !== undefined && mon.uri !== "") {+ updateValues.url = mon.uri;+ }++ return applyUpdate(rpcCtx, dbMon.id, updateValues, (data) =>+ dbMonitorToIcmpProto(data, privateLocationIds),+ );+ },+async triggerMonitor(req, ctx) {const rpcCtx = getRpcContext(ctx);const limits = rpcCtx.workspace.limits;@@ -564,6 +655,7 @@ export const monitorServiceImpl: ServiceImpl<typeof MonitorService> = {const httpMonitors: HTTPMonitor[] = [];const tcpMonitors: TCPMonitor[] = [];const dnsMonitors: DNSMonitor[] = [];+ const icmpMonitors: ICMPMonitor[] = [];for (const data of parsedMonitors) {const privateLocationIds = plMap.get(data.id) ?? [];@@ -577,6 +669,9 @@ export const monitorServiceImpl: ServiceImpl<typeof MonitorService> = {case "dns":dnsMonitors.push(dbMonitorToDnsProto(data, privateLocationIds));break;+ case "icmp":+ icmpMonitors.push(dbMonitorToIcmpProto(data, privateLocationIds));+ break;}}@@ -584,6 +679,7 @@ export const monitorServiceImpl: ServiceImpl<typeof MonitorService> = {httpMonitors,tcpMonitors,dnsMonitors,+ icmpMonitors,totalSize: totalCount,};},@@ -664,10 +760,19 @@ export const monitorServiceImpl: ServiceImpl<typeof MonitorService> = {},};break;+ case "icmp":+ monitorConfig = {+ $typeName: "openstatus.monitor.v1.MonitorConfig",+ config: {+ case: "icmp",+ value: dbMonitorToIcmpProto(monitorData, privateLocationIds),+ },+ };+ break;default:throw monitorTypeMismatchError(req.id,- "http, tcp, or dns",+ "http, tcp, dns, or icmp",monitorData.jobType,);}diff --git a/apps/server/src/routes/rpc/handlers/monitor/validators.test.ts b/apps/server/src/routes/rpc/handlers/monitor/validators.test.tsindex 90b564930..216e77205 100644--- a/apps/server/src/routes/rpc/handlers/monitor/validators.test.ts+++ b/apps/server/src/routes/rpc/handlers/monitor/validators.test.ts@@ -1,3 +1,4 @@+import { ConnectError } from "@connectrpc/connect";import { Periodicity, Region } from "@openstatus/proto/monitor/v1";import { expect } from "@std/expect";import { describe, test } from "@std/testing/bdd";@@ -9,6 +10,7 @@ import {toValidMethod,toValidPeriodicity,validateCommonMonitorFields,+ validateMonitorPatchBounds,} from "./validators";describe("getCommonCreateInput", () => {@@ -167,3 +169,82 @@ describe("validateCommonMonitorFields", () => {).toEqual(["ams"]);});});++describe("validateMonitorPatchBounds", () => {+ test("accepts an empty patch", () => {+ validateMonitorPatchBounds({});+ });++ test("accepts values at the documented limits", () => {+ validateMonitorPatchBounds({+ name: "a".repeat(256),+ uri: "b".repeat(2048),+ description: "c".repeat(1024),+ timeout: BigInt(120_000),+ degradedAt: BigInt(120_000),+ retry: BigInt(10),+ });+ });++ test("rejects a retry above the proto maximum", () => {+ expect(() => validateMonitorPatchBounds({ retry: BigInt(11) })).toThrow(+ ConnectError,+ );+ });++ test("rejects a negative retry", () => {+ // Proto int64 accepts a negative; only the bound rejects it. Unchecked it+ // reaches the checker, where `uint64(retry)` becomes a huge retry count.+ expect(() => validateMonitorPatchBounds({ retry: BigInt(-1) })).toThrow(+ ConnectError,+ );+ });++ test("rejects a timeout above the proto maximum", () => {+ expect(() =>+ validateMonitorPatchBounds({ timeout: BigInt(120_001) }),+ ).toThrow(ConnectError);+ });++ test("rejects a degradedAt outside its range", () => {+ expect(() =>+ validateMonitorPatchBounds({ degradedAt: BigInt(120_001) }),+ ).toThrow(ConnectError);+ expect(() =>+ validateMonitorPatchBounds({ degradedAt: BigInt(-1) }),+ ).toThrow(ConnectError);+ });++ test("rejects an over-long description, name and uri", () => {+ expect(() =>+ validateMonitorPatchBounds({ description: "c".repeat(1025) }),+ ).toThrow(ConnectError);+ expect(() => validateMonitorPatchBounds({ name: "a".repeat(257) })).toThrow(+ ConnectError,+ );+ expect(() => validateMonitorPatchBounds({ uri: "b".repeat(2049) })).toThrow(+ ConnectError,+ );+ });++ test("checks HTTP's `url` as well as the other types' `uri`", () => {+ expect(() => validateMonitorPatchBounds({ url: "b".repeat(2049) })).toThrow(+ ConnectError,+ );+ });++ test("skips fields the patch does not supply, matching getCommonUpdateInput", () => {+ // Zero timeout/retry mean "not supplied", so they must not be range-checked+ // — otherwise a name-only patch would be rejected on an unrelated field.+ validateMonitorPatchBounds({ timeout: BigInt(0), retry: BigInt(0) });+ validateMonitorPatchBounds({ name: "" });+ validateMonitorPatchBounds({ uri: "" });+ });++ test("rejects more regions than the proto allows", () => {+ const tooMany = Array.from({ length: 29 }, () => 1 as Region);+ expect(() => validateMonitorPatchBounds({ regions: tooMany })).toThrow(+ ConnectError,+ );+ });+});diff --git a/apps/server/src/routes/rpc/handlers/monitor/validators.ts b/apps/server/src/routes/rpc/handlers/monitor/validators.tsindex ce876ab9b..23aeb2c8d 100644--- a/apps/server/src/routes/rpc/handlers/monitor/validators.ts+++ b/apps/server/src/routes/rpc/handlers/monitor/validators.ts@@ -58,6 +58,109 @@ export function validateCommonMonitorFields(mon: { regions?: Region[] }): void {}}+/**+ * The bounds protovalidate enforces on a complete monitor message. Update RPCs+ * skip the interceptor — a partial patch cannot satisfy `min_len` on the fields+ * it omits — so nothing else checks these on an update: `updateMonitorConfig`+ * writes whatever it is handed straight to the column.+ *+ * Keep in sync with the `buf.validate` constraints in `*_monitor.proto`.+ */+const MONITOR_BOUNDS = {+ nameMaxLen: 256,+ uriMaxLen: 2048,+ descriptionMaxLen: 1024,+ timeoutMaxMs: 120_000,+ degradedAtMaxMs: 120_000,+ retryMax: 10,+ regionsMaxItems: 28,+} as const;++function invalidArgument(message: string): never {+ throw new ConnectError(message, Code.InvalidArgument);+}++/**+ * Apply those bounds to whatever an update actually supplied. The "supplied"+ * tests mirror `getCommonUpdateInput` exactly: a field this skips is a field+ * that never reaches the database.+ */+export function validateMonitorPatchBounds(mon: {+ name?: string;+ uri?: string;+ url?: string;+ timeout?: bigint;+ degradedAt?: bigint;+ retry?: bigint;+ description?: string;+ regions?: Region[];+}): void {+ if (mon.name !== undefined && mon.name !== "") {+ if (mon.name.length > MONITOR_BOUNDS.nameMaxLen) {+ invalidArgument(+ `monitor.name: must be at most ${MONITOR_BOUNDS.nameMaxLen} characters [string.max_len]`,+ );+ }+ }++ // HTTP calls it `url`, the other three call it `uri`.+ const target = mon.uri ?? mon.url;+ if (target !== undefined && target !== "") {+ if (target.length > MONITOR_BOUNDS.uriMaxLen) {+ invalidArgument(+ `monitor.uri: must be at most ${MONITOR_BOUNDS.uriMaxLen} characters [string.max_len]`,+ );+ }+ }++ if (mon.description !== undefined) {+ if (mon.description.length > MONITOR_BOUNDS.descriptionMaxLen) {+ invalidArgument(+ `monitor.description: must be at most ${MONITOR_BOUNDS.descriptionMaxLen} characters [string.max_len]`,+ );+ }+ }++ if (mon.timeout !== undefined && mon.timeout !== BigInt(0)) {+ if (+ mon.timeout < BigInt(0) ||+ mon.timeout > BigInt(MONITOR_BOUNDS.timeoutMaxMs)+ ) {+ invalidArgument(+ `monitor.timeout: must be between 0 and ${MONITOR_BOUNDS.timeoutMaxMs} [int64.gte_lte]`,+ );+ }+ }++ if (mon.degradedAt !== undefined) {+ if (+ mon.degradedAt < BigInt(0) ||+ mon.degradedAt > BigInt(MONITOR_BOUNDS.degradedAtMaxMs)+ ) {+ invalidArgument(+ `monitor.degraded_at: must be between 0 and ${MONITOR_BOUNDS.degradedAtMaxMs} [int64.gte_lte]`,+ );+ }+ }++ if (mon.retry !== undefined && mon.retry !== BigInt(0)) {+ if (mon.retry < BigInt(0) || mon.retry > BigInt(MONITOR_BOUNDS.retryMax)) {+ invalidArgument(+ `monitor.retry: must be between 0 and ${MONITOR_BOUNDS.retryMax} [int64.gte_lte]`,+ );+ }+ }++ if (+ mon.regions !== undefined &&+ mon.regions.length > MONITOR_BOUNDS.regionsMaxItems+ ) {+ invalidArgument(+ `monitor.regions: must contain at most ${MONITOR_BOUNDS.regionsMaxItems} items [repeated.max_items]`,+ );+ }+}+/*** Extract the fields every monitor type shares, in the shape* `createMonitor` takes. Defaults are applied here rather than left todiff --git a/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts b/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.tsindex 38a05bdbb..6ebe54be4 100644--- a/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts+++ b/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts@@ -1,5 +1,6 @@import type { Interceptor } from "@connectrpc/connect";import { Events } from "@openstatus/analytics";+import { MonitorService } from "@openstatus/proto/monitor/v1";// @ts-nocheck — ConnectRPC's deep generic types (AnyFn, UnaryResponse, etc.)// are incompatible with the test mocks. All runtime behavior is correct.import {@@ -115,12 +116,12 @@ describe("trackingInterceptor", () => {});});- test("extracts additional props from message", async () => {+ test("extracts additional props from nested create message", async () => {const interceptor = trackingInterceptor();const req = createMockRequest("openstatus.monitor.v1.MonitorService","CreateHTTPMonitor",- { url: "https://example.com", jobType: "http", name: "my-monitor" },+ { monitor: { url: "https://example.com", name: "my-monitor" } },);const next = mockNext({});@@ -133,6 +134,24 @@ describe("trackingInterceptor", () => {});});+ test("maps icmp uri to url and stamps jobType", async () => {+ const interceptor = trackingInterceptor();+ const req = createMockRequest(+ "openstatus.monitor.v1.MonitorService",+ "CreateICMPMonitor",+ { monitor: { name: "ping", uri: "example.com" } },+ );+ const next = mockNext({});++ await interceptor(next)(req as never);+ await Promise.resolve();++ expect(mockTrack).toHaveBeenCalledWith({+ ...Events.CreateMonitor,+ additionalProps: { url: "example.com", jobType: "icmp" },+ });+ });+test("silently skips unmapped methods", async () => {const interceptor = trackingInterceptor();const req = createMockRequest(@@ -237,4 +256,37 @@ describe("RPC_EVENT_MAP", () => {expect(mapping.event.channel).toBeDefined();}});++ // Derived from the service definition rather than a hand-written list, so a+ // newly added Create*/Update*/Delete* RPC fails here instead of silently+ // going untracked — which is how ICMP was missed.+ test("every mutating MonitorService RPC is tracked", () => {+ const mutating = Object.values(MonitorService.method)+ .map((m) => m.name)+ .filter((name) => /^(Create|Update|Delete)/.test(name));++ expect(mutating.length).toBeGreaterThan(0);++ const untracked = mutating.filter(+ (name) =>+ !(`openstatus.monitor.v1.MonitorService/${name}` in RPC_EVENT_MAP),+ );++ expect(untracked).toEqual([]);+ });++ test("ICMP monitor mutations are tracked like the other monitor types", () => {+ const create =+ RPC_EVENT_MAP["openstatus.monitor.v1.MonitorService/CreateICMPMonitor"];+ const update =+ RPC_EVENT_MAP["openstatus.monitor.v1.MonitorService/UpdateICMPMonitor"];++ expect(create?.event).toEqual(Events.CreateMonitor);+ expect(update?.event).toEqual(Events.UpdateMonitor);+ // Same props as the sibling create entries.+ expect(create?.eventProps).toEqual(+ RPC_EVENT_MAP["openstatus.monitor.v1.MonitorService/CreateDNSMonitor"]+ ?.eventProps,+ );+ });});diff --git a/apps/server/src/routes/rpc/interceptors/tracking.ts b/apps/server/src/routes/rpc/interceptors/tracking.tsindex 0cb8794f3..4ae4ff357 100644--- a/apps/server/src/routes/rpc/interceptors/tracking.ts+++ b/apps/server/src/routes/rpc/interceptors/tracking.ts@@ -14,8 +14,23 @@ const logger = getLogger("api-server");type RpcEventMapping = {event: EventProps;eventProps?: string[];+ normalizeInput?: (message: unknown) => Record<string, unknown>;};+// Create*Monitor requests nest the config under `monitor`, so top-level+// extraction yields nothing; ICMP names its target `uri` and none of them+// carries jobType on the wire.+function monitorCreateInput(jobType: string) {+ return (message: unknown): Record<string, unknown> => {+ if (typeof message !== "object" || message === null) return {};+ const { monitor } = message as {+ monitor?: Record<string, unknown> | undefined;+ };+ if (!monitor) return {};+ return { ...monitor, url: monitor.uri ?? monitor.url, jobType };+ };+}+/*** Mapping from "ServiceTypeName/MethodName" to OpenPanel event + optional props.* Keys use PascalCase method names matching DescMethod.name (the proto source name).@@ -26,14 +41,22 @@ export const RPC_EVENT_MAP: Record<string, RpcEventMapping> = {"openstatus.monitor.v1.MonitorService/CreateHTTPMonitor": {event: Events.CreateMonitor,eventProps: ["url", "jobType"],+ normalizeInput: monitorCreateInput("http"),},"openstatus.monitor.v1.MonitorService/CreateTCPMonitor": {event: Events.CreateMonitor,eventProps: ["url", "jobType"],+ normalizeInput: monitorCreateInput("tcp"),},"openstatus.monitor.v1.MonitorService/CreateDNSMonitor": {event: Events.CreateMonitor,eventProps: ["url", "jobType"],+ normalizeInput: monitorCreateInput("dns"),+ },+ "openstatus.monitor.v1.MonitorService/CreateICMPMonitor": {+ event: Events.CreateMonitor,+ eventProps: ["url", "jobType"],+ normalizeInput: monitorCreateInput("icmp"),},"openstatus.monitor.v1.MonitorService/UpdateHTTPMonitor": {event: Events.UpdateMonitor,@@ -44,6 +67,9 @@ export const RPC_EVENT_MAP: Record<string, RpcEventMapping> = {"openstatus.monitor.v1.MonitorService/UpdateDNSMonitor": {event: Events.UpdateMonitor,},+ "openstatus.monitor.v1.MonitorService/UpdateICMPMonitor": {+ event: Events.UpdateMonitor,+ },"openstatus.monitor.v1.MonitorService/DeleteMonitor": {event: Events.DeleteMonitor,},@@ -138,7 +164,8 @@ export function trackingInterceptor(): Interceptor {return response;}- const additionalProps = parseInputToProps(req.message, mapping.eventProps);+ const input = mapping.normalizeInput?.(req.message) ?? req.message;+ const additionalProps = parseInputToProps(input, mapping.eventProps);setupAnalytics({userId: `api_${rpcCtx.workspace.id}`,diff --git a/apps/server/src/routes/rpc/interceptors/validation.ts b/apps/server/src/routes/rpc/interceptors/validation.tsindex 34b427d02..84611c3e2 100644--- a/apps/server/src/routes/rpc/interceptors/validation.ts+++ b/apps/server/src/routes/rpc/interceptors/validation.ts@@ -7,6 +7,7 @@ const SKIP_VALIDATION_METHODS = new Set(["UpdateHTTPMonitor","UpdateTCPMonitor","UpdateDNSMonitor",+ "UpdateICMPMonitor",]);// protovalidate >=1.2 dropped the "value " prefix from the string.patterndiff --git a/apps/server/src/routes/v1/monitors/run/post.ts b/apps/server/src/routes/v1/monitors/run/post.tsindex c49a97821..0c34dcb8d 100644--- a/apps/server/src/routes/v1/monitors/run/post.ts+++ b/apps/server/src/routes/v1/monitors/run/post.ts@@ -21,6 +21,7 @@ import { HTTPException } from "hono/http-exception";import type { monitorsApi } from "..";import { ParamsSchema, TriggerResult } from "../schema";+import { assertLegacyRunnableJobType } from "../utils";import { QuerySchema } from "./schema";const postMonitor = createRoute({@@ -98,6 +99,8 @@ export function registerRunMonitor(api: typeof monitorsApi) {const row = parseMonitor.data;+ assertLegacyRunnableJobType(row.jobType);+// Maybe later overwrite the regionconst monitorStatusData = await dbdiff --git a/apps/server/src/routes/v1/monitors/schema.ts b/apps/server/src/routes/v1/monitors/schema.tsindex bc24a6a89..21ee0ed36 100644--- a/apps/server/src/routes/v1/monitors/schema.ts+++ b/apps/server/src/routes/v1/monitors/schema.ts@@ -306,6 +306,7 @@ export const TCPTriggerResult = z.object({errorMessage: z.string().optional().nullable(),});+// Only the two types the v1 API can run — see `assertLegacyRunnableJobType`.export const TriggerResult = z.discriminatedUnion("jobType", [HTTPTriggerResult,TCPTriggerResult,diff --git a/apps/server/src/routes/v1/monitors/trigger/post.test.ts b/apps/server/src/routes/v1/monitors/trigger/post.test.tsindex 028a0a713..f0b322c27 100644--- a/apps/server/src/routes/v1/monitors/trigger/post.test.ts+++ b/apps/server/src/routes/v1/monitors/trigger/post.test.ts@@ -1,3 +1,4 @@+import { createMonitor } from "@openstatus/db/src/test/factories";import { afterEach, expect, mock, test } from "@openstatus/test-utils";import { app } from "@/index";@@ -184,3 +185,58 @@ test("trigger monitor with multiple regions should return result id", async () =expect(result.success).toBe(true);expect(json.resultId).toBeDefined();});++test("trigger ICMP monitor is rejected by the legacy v1 API", async () => {+ const icmpMonitor = await createMonitor(1, {+ jobType: "icmp",+ url: "1.1.1.1",+ active: true,+ regions: "ams",+ periodicity: "10m",+ });++ mockFetch.mockReturnValue(+ Promise.resolve(new Response(null, { status: 200 })),+ );++ const res = await app.request(`/v1/monitor/${icmpMonitor.id}/trigger`, {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(400);++ const json = await res.json();+ expect(json.message).toContain("not supported by the v1 API");++ // Rejected before any probe leaves the process.+ expect(mockFetch.mock.calls.length).toBe(0);+});++test("trigger DNS monitor is rejected by the legacy v1 API", async () => {+ const dnsMonitor = await createMonitor(1, {+ jobType: "dns",+ url: "openstatus.dev",+ active: true,+ regions: "ams",+ periodicity: "10m",+ });++ mockFetch.mockReturnValue(+ Promise.resolve(new Response(null, { status: 200 })),+ );++ const res = await app.request(`/v1/monitor/${dnsMonitor.id}/trigger`, {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(400);+ expect(mockFetch.mock.calls.length).toBe(0);+});diff --git a/apps/server/src/routes/v1/monitors/trigger/post.ts b/apps/server/src/routes/v1/monitors/trigger/post.tsindex 3e502967c..70f0da060 100644--- a/apps/server/src/routes/v1/monitors/trigger/post.ts+++ b/apps/server/src/routes/v1/monitors/trigger/post.ts@@ -17,6 +17,7 @@ import {import { OpenStatusApiError, openApiErrorResponses } from "@/libs/errors";import type { monitorsApi } from "..";+import { assertLegacyRunnableJobType } from "../utils";import { ParamsSchema, TriggerSchema } from "./schema";const postRoute = createRoute({@@ -100,6 +101,8 @@ export function registerTriggerMonitor(api: typeof monitorsApi) {const row = validateMonitor.data;+ assertLegacyRunnableJobType(row.jobType);+// Maybe later overwrite the regionconst _monitorStatus = await dbdiff --git a/apps/server/src/routes/v1/monitors/utils.ts b/apps/server/src/routes/v1/monitors/utils.tsindex 25fd4cb10..92225ffc6 100644--- a/apps/server/src/routes/v1/monitors/utils.ts+++ b/apps/server/src/routes/v1/monitors/utils.ts@@ -33,6 +33,24 @@ export function assertSafeMonitorUrl(args: {}}+/**+ * The v1 API is legacy and frozen to the monitor types it already shipped:+ * `POST /v1/monitor` refuses anything but http/tcp, so a newer type can only+ * reach these routes on a monitor created elsewhere. Running one here would+ * dispatch a probe the route cannot describe back to the caller. New types are+ * served by the ConnectRPC API (`TriggerMonitor`) instead.+ */+const LEGACY_RUNNABLE_JOB_TYPES = ["http", "tcp"];++export function assertLegacyRunnableJobType(jobType: string): void {+ if (!LEGACY_RUNNABLE_JOB_TYPES.includes(jobType)) {+ throw new OpenStatusApiError({+ code: "BAD_REQUEST",+ message: `Running a '${jobType}' monitor is not supported by the v1 API. Use the ConnectRPC MonitorService.TriggerMonitor instead.`,+ });+ }+}+export const getAssertions = (assertions: z.infer<typeof assertion>[],): Assertion[] => {diff --git a/apps/server/static/openapi.yaml b/apps/server/static/openapi.yamlindex 507f9fae7..532ee0485 100644--- a/apps/server/static/openapi.yaml+++ b/apps/server/static/openapi.yaml@@ -470,6 +470,28 @@ components:title: CreateHTTPMonitorResponseadditionalProperties: falsedescription: CreateHTTPMonitorResponse is the response after creating an HTTP monitor.+ openstatus.monitor.v1.CreateICMPMonitorRequest:+ type: object+ properties:+ monitor:+ title: monitor+ description: Monitor configuration (required).+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: CreateICMPMonitorRequest+ required:+ - monitor+ additionalProperties: false+ description: CreateICMPMonitorRequest is the request to create a new ICMP monitor.+ openstatus.monitor.v1.CreateICMPMonitorResponse:+ type: object+ properties:+ monitor:+ title: monitor+ description: The created monitor with assigned ID.+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: CreateICMPMonitorResponse+ additionalProperties: false+ description: CreateICMPMonitorResponse is the response after creating an ICMP monitor.openstatus.monitor.v1.CreateTCPMonitorRequest:type: objectproperties:@@ -665,7 +687,7 @@ components:properties:monitor:title: monitor- description: The monitor configuration (one of HTTP, TCP, or DNS).+ description: The monitor configuration (one of HTTP, TCP, DNS, or ICMP).$ref: '#/components/schemas/openstatus.monitor.v1.MonitorConfig'title: GetMonitorResponseadditionalProperties: false@@ -1189,6 +1211,109 @@ components:title: HeadersadditionalProperties: falsedescription: Headers represents a key-value pair for HTTP headers.+ openstatus.monitor.v1.ICMPMonitor:+ type: object+ properties:+ id:+ type: string+ title: id+ description: Unique identifier for the monitor (output only for create requests).+ name:+ type: string+ examples:+ - Ping Gateway+ title: name+ maxLength: 256+ minLength: 1+ description: Name of the monitor (required, max 256 characters).+ uri:+ type: string+ examples:+ - 1.1.1.1+ title: uri+ maxLength: 2048+ minLength: 1+ description: URI to monitor in format "host or IP" (required, max 2048 characters).+ periodicity:+ not:+ enum:+ - PERIODICITY_UNSPECIFIED+ title: periodicity+ description: Check periodicity (required).+ $ref: '#/components/schemas/openstatus.monitor.v1.Periodicity'+ timeout:+ type:+ - integer+ - string+ title: timeout+ maximum: 120000+ minimum: 0+ format: int64+ description: Timeout in milliseconds (0-120000, defaults to 45000).+ degradedAt:+ type:+ - integer+ - string+ - "null"+ title: degraded_at+ maximum: 120000+ minimum: 0+ format: int64+ description: Latency threshold for degraded status in milliseconds (optional, 0-120000).+ retry:+ type:+ - integer+ - string+ title: retry+ maximum: 10+ minimum: 0+ format: int64+ description: Number of retry attempts (0-10, defaults to 3).+ description:+ type:+ - string+ - "null"+ title: description+ maxLength: 1024+ description: Description of the monitor (optional).+ active:+ type:+ - boolean+ - "null"+ title: active+ description: Whether the monitor is active (defaults to false).+ public:+ type:+ - boolean+ - "null"+ title: public+ description: Whether the monitor is publicly visible (defaults to false).+ regions:+ type: array+ items:+ $ref: '#/components/schemas/openstatus.monitor.v1.Region'+ title: regions+ maxItems: 28+ description: Geographic regions to run checks from.+ openTelemetry:+ title: open_telemetry+ description: OpenTelemetry configuration for exporting metrics.+ $ref: '#/components/schemas/openstatus.monitor.v1.OpenTelemetryConfig'+ status:+ title: status+ description: Current operational status of the monitor.+ $ref: '#/components/schemas/openstatus.monitor.v1.MonitorStatus'+ privateLocationIds:+ type: array+ items:+ type: string+ readOnly: true+ title: private_location_ids+ description: IDs of private locations that run this monitor. Read-only.+ readOnly: true+ title: ICMPMonitor+ additionalProperties: false+ description: ICMPMonitor defines the configuration for a ICMP monitor.openstatus.monitor.v1.ListMonitorHTTPResponseLogsRequest:type: objectproperties:@@ -1293,6 +1418,12 @@ components:$ref: '#/components/schemas/openstatus.monitor.v1.DNSMonitor'title: dns_monitorsdescription: DNS monitors in the workspace.+ icmpMonitors:+ type: array+ items:+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: icmp_monitors+ description: ICMP monitors in the workspace.totalSize:type: integertitle: total_size@@ -1322,6 +1453,15 @@ components:title: httprequired:- http+ - type: object+ properties:+ icmp:+ title: icmp+ description: ICMP monitor configuration.+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: icmp+ required:+ - icmp- type: objectproperties:tcp:@@ -1695,6 +1835,33 @@ components:title: UpdateHTTPMonitorResponseadditionalProperties: falsedescription: UpdateHTTPMonitorResponse is the response after updating an HTTP monitor.+ openstatus.monitor.v1.UpdateICMPMonitorRequest:+ type: object+ properties:+ id:+ type: string+ title: id+ minLength: 1+ description: Monitor ID to update (required).+ monitor:+ oneOf:+ - $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ - type: "null"+ title: monitor+ description: Updated monitor configuration (all fields optional for partial updates).+ title: UpdateICMPMonitorRequest+ additionalProperties: false+ description: UpdateICMPMonitorRequest is the request to update an existing ICMP monitor.+ openstatus.monitor.v1.UpdateICMPMonitorResponse:+ type: object+ properties:+ monitor:+ title: monitor+ description: The updated monitor.+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: UpdateICMPMonitorResponse+ additionalProperties: false+ description: UpdateICMPMonitorResponse is the response after updating an ICMP monitor.openstatus.monitor.v1.UpdateTCPMonitorRequest:type: objectproperties:@@ -5046,6 +5213,32 @@ paths:application/json:schema:$ref: '#/components/schemas/openstatus.monitor.v1.CreateHTTPMonitorResponse'+ /rpc/openstatus.monitor.v1.MonitorService/CreateICMPMonitor:+ post:+ tags:+ - MonitorService+ summary: CreateICMPMonitor+ description: CreateICMPMonitor creates a new ICMP monitor.+ operationId: MonitorService_CreateICMPMonitor+ requestBody:+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.CreateICMPMonitorRequest'+ required: true+ responses:+ default:+ description: Error+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/connect.error'+ "200":+ description: Success+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.CreateICMPMonitorResponse'/rpc/openstatus.monitor.v1.MonitorService/CreateTCPMonitor:post:tags:@@ -5105,7 +5298,7 @@ paths:summary: GetMonitordescription: |-GetMonitor returns a single monitor by ID within the authenticated workspace.- Returns the monitor configuration (HTTP, TCP, or DNS) using the MonitorConfig oneof type.+ Returns the monitor configuration (HTTP, TCP, DNS, or ICMP) using the MonitorConfig oneof type.operationId: MonitorService_GetMonitor.getparameters:- name: message@@ -5133,7 +5326,7 @@ paths:summary: GetMonitordescription: |-GetMonitor returns a single monitor by ID within the authenticated workspace.- Returns the monitor configuration (HTTP, TCP, or DNS) using the MonitorConfig oneof type.+ Returns the monitor configuration (HTTP, TCP, DNS, or ICMP) using the MonitorConfig oneof type.operationId: MonitorService_GetMonitorrequestBody:content:@@ -5492,6 +5685,32 @@ paths:application/json:schema:$ref: '#/components/schemas/openstatus.monitor.v1.UpdateHTTPMonitorResponse'+ /rpc/openstatus.monitor.v1.MonitorService/UpdateICMPMonitor:+ post:+ tags:+ - MonitorService+ summary: UpdateICMPMonitor+ description: UpdateICMPMonitor updates an existing ICMP monitor.+ operationId: MonitorService_UpdateICMPMonitor+ requestBody:+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.UpdateICMPMonitorRequest'+ required: true+ responses:+ default:+ description: Error+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/connect.error'+ "200":+ description: Success+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.UpdateICMPMonitorResponse'/rpc/openstatus.monitor.v1.MonitorService/UpdateTCPMonitor:post:tags:diff --git a/apps/web/src/content/docs.config.ts b/apps/web/src/content/docs.config.tsindex ab2a78d6b..85573dfd5 100644--- a/apps/web/src/content/docs.config.ts+++ b/apps/web/src/content/docs.config.ts@@ -243,6 +243,7 @@ export const docsNav: DocsNavSection[] = [{ slug: "reference/mcp-server", label: "MCP Server" },{ slug: "reference/dns-monitor", label: "DNS Monitor Reference" },{ slug: "reference/http-monitor", label: "HTTP Monitor Reference" },+ { slug: "reference/icmp-monitor", label: "ICMP Monitor Reference" },{ slug: "reference/incident", label: "Incident Reference" },{ slug: "reference/tcp-monitor", label: "TCP Monitor Reference" },{diff --git a/apps/web/src/content/pages/changelog/icmp-monitoring.mdx b/apps/web/src/content/pages/changelog/icmp-monitoring.mdxnew file mode 100644index 000000000..8501892b6--- /dev/null+++ b/apps/web/src/content/pages/changelog/icmp-monitoring.mdx@@ -0,0 +1,14 @@+---+title: "ICMP Monitoring"+description: "Monitor your hosts with ICMP ping from openstatus."+publishedAt: "2026-07-21"+author: "openstatus"+category: "monitoring"+---++We're excited to announce that ICMP monitoring is now available in openstatus! You can now ping any host — routers, gateways, or bare network endpoints — to track reachability, round-trip latency, and packet loss, even when there's no TCP or HTTP service to check.++Each check sends three echo requests and reports the average latency along with packet loss, so you get an early signal on lossy or degraded links.++#### Get Started 🚀+To start monitoring a host, add a new monitor and select "ICMP" as your monitor type, then enter the host or IP address you want to ping.diff --git a/apps/web/src/content/pages/docs/reference/icmp-monitor.mdx b/apps/web/src/content/pages/docs/reference/icmp-monitor.mdxnew file mode 100644index 000000000..d22f3cd71--- /dev/null+++ b/apps/web/src/content/pages/docs/reference/icmp-monitor.mdx@@ -0,0 +1,98 @@+---+category: Reference+title: ICMP Monitor Reference+description: Complete technical specification for ICMP (ping) monitoring.+---++An ICMP monitor sends ICMP echo requests ("pings") to a host to verify that it is reachable and to measure round-trip latency. This is useful for monitoring hosts that expose no TCP or HTTP service, such as routers, gateways, and bare network endpoints.++Each check sends **3 echo requests** spaced ~100ms apart. The check is considered up as long as **at least one** reply is received; it fails only when all three packets are lost. The reported latency is the **average** round-trip time of the replies received, and packet loss is recorded per check.++**Use cases:**++- Router, gateway, and firewall reachability.+- Baseline network latency and packet-loss tracking.+- Monitoring IoT and network devices without an application-layer service.++## Configuration++### Host++**Type:** String (required)+**Format:** Hostname or IP address, without a port++The host to ping. Both IPv4 and IPv6 targets are supported — the resolved address family selects the protocol automatically.++**Examples:**+- `openstatus.dev`+- `1.1.1.1`+- `2001:4860:4860::8888`++### Regions++**Type:** Array of strings (required)+**Format:** Region identifiers (e.g., `iad`, `jnb`)++The geographical regions from which the ping is sent. See the [Location Reference](/docs/reference/location) for the full list of regions and the IPs to allowlist.++### Frequency++**Type:** String (required)+**Format:** Duration string (e.g., `30s`, `1m`, `1h`)++The interval at which the ICMP monitor pings the target host. Supported frequencies:+- `30 seconds`+- `1 minute`+- `5 minutes`+- `10 minutes`+- `30 minutes`+- `1 hour`++### Response time thresholds++#### Timeout++**Type:** Duration (optional)+**Default:** `45 seconds`++The total budget for the whole check (all three echo requests). Each packet waits at most the remaining budget for a reply.++#### Degraded++**Type:** Duration (optional)++The average latency after which a check is considered to be in a degraded performance state, giving early warning of network slowdowns.++### Retry++**Type:** Integer (optional)+**Default:** `3`++The number of times the monitor retries a fully failed check (all packets lost) before reporting a definitive error.++### OpenTelemetry++Configures the export of monitoring metrics to an OpenTelemetry-compatible observability platform.++#### OTLP endpoint++**Type:** String (optional)+**Protocol:** HTTP only++The OTLP endpoint URL where collected metrics — including latency and packet loss — are exported. Only HTTP endpoints are supported.++#### OTLP headers++**Type:** Key-value pairs (optional)++Custom headers to include when sending metrics to your OTLP endpoint, commonly used for authentication or tenant identification.++**Common example:**+```+Authorization: Bearer <your_token>+```++## Related resources++- **[Create your first monitor](/docs/tutorial/create-your-first-monitor)** — step-by-step tutorial on setting up a monitor.+- **[CLI reference](/docs/reference/cli-reference)** — manage monitors programmatically from the command line.diff --git a/apps/web/src/lib/tb.ts b/apps/web/src/lib/tb.tsindex 1634abf6c..437bc5731 100644--- a/apps/web/src/lib/tb.ts+++ b/apps/web/src/lib/tb.ts@@ -11,7 +11,7 @@ export const tb = new OSTinybird({// REMINDER: we could extend the limits (WorkspacePlan) by// knowing which plan the user is on and disable some periodsconst periods = ["1d", "7d", "14d"] as const;-const types = ["http", "tcp"] as const;+const types = ["http", "tcp", "icmp"] as const;// FIXME: check we we can also use Period from elswheretype Period = (typeof periods)[number];@@ -25,6 +25,7 @@ export function prepareListByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpListDaily,tcp: tb.legacy_tcpListDaily,+ icmp: tb.icmpListDaily,} as const;return { getData: getData[type] };}@@ -32,6 +33,7 @@ export function prepareListByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpListWeekly,tcp: tb.legacy_tcpListWeekly,+ icmp: tb.icmpListWeekly,} as const;return { getData: getData[type] };}@@ -39,6 +41,7 @@ export function prepareListByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpListBiweekly,tcp: tb.legacy_tcpListBiweekly,+ icmp: tb.icmpListBiweekly,} as const;return { getData: getData[type] };}@@ -46,6 +49,7 @@ export function prepareListByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpListDaily,tcp: tb.legacy_tcpListDaily,+ icmp: tb.icmpListDaily,} as const;return { getData: getData[type] };}@@ -58,6 +62,7 @@ export function prepareMetricsByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpMetricsDaily,tcp: tb.legacy_tcpMetricsDaily,+ icmp: tb.icmpMetricsDaily,} as const;return { getData: getData[type] };}@@ -65,6 +70,7 @@ export function prepareMetricsByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpMetricsWeekly,tcp: tb.legacy_tcpMetricsWeekly,+ icmp: tb.icmpMetricsWeekly,} as const;return { getData: getData[type] };}@@ -72,6 +78,7 @@ export function prepareMetricsByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpMetricsBiweekly,tcp: tb.legacy_tcpMetricsBiweekly,+ icmp: tb.icmpMetricsBiweekly,} as const;return { getData: getData[type] };}@@ -79,6 +86,7 @@ export function prepareMetricsByPeriod(period: Period, type: Type = "http") {const getData = {http: tb.legacy_httpMetricsDaily,tcp: tb.legacy_tcpMetricsDaily,+ icmp: tb.icmpMetricsDaily,} as const;return { getData: getData[type] };}@@ -94,6 +102,7 @@ export function prepareMetricByRegionByPeriod(const getData = {http: tb.httpMetricsByRegionDaily,tcp: tb.tcpMetricsByRegionDaily,+ icmp: tb.icmpMetricsByRegionDaily,} as const;return { getData: getData[type] };}@@ -101,6 +110,7 @@ export function prepareMetricByRegionByPeriod(const getData = {http: tb.httpMetricsByRegionWeekly,tcp: tb.tcpMetricsByRegionWeekly,+ icmp: tb.icmpMetricsByRegionWeekly,} as const;return { getData: getData[type] };}@@ -108,6 +118,7 @@ export function prepareMetricByRegionByPeriod(const getData = {http: tb.httpMetricsByRegionBiweekly,tcp: tb.tcpMetricsByRegionBiweekly,+ icmp: tb.icmpMetricsByRegionBiweekly,} as const;return { getData: getData[type] };}@@ -115,6 +126,7 @@ export function prepareMetricByRegionByPeriod(const getData = {http: tb.httpMetricsByRegionDaily,tcp: tb.tcpMetricsByRegionDaily,+ icmp: tb.icmpMetricsByRegionDaily,} as const;return { getData: getData[type] };}@@ -130,6 +142,7 @@ export function prepareMetricByIntervalByPeriod(const getData = {http: tb.httpMetricsByIntervalDaily,tcp: tb.tcpMetricsByIntervalDaily,+ icmp: tb.icmpMetricsByIntervalDaily,} as const;return { getData: getData[type] };}@@ -137,6 +150,7 @@ export function prepareMetricByIntervalByPeriod(const getData = {http: tb.httpMetricsByIntervalWeekly,tcp: tb.tcpMetricsByIntervalWeekly,+ icmp: tb.icmpMetricsByIntervalWeekly,} as const;return { getData: getData[type] };}@@ -144,6 +158,7 @@ export function prepareMetricByIntervalByPeriod(const getData = {http: tb.httpMetricsByIntervalBiweekly,tcp: tb.tcpMetricsByIntervalBiweekly,+ icmp: tb.icmpMetricsByIntervalBiweekly,} as const;return { getData: getData[type] };}@@ -151,6 +166,7 @@ export function prepareMetricByIntervalByPeriod(const getData = {http: tb.httpMetricsByIntervalDaily,tcp: tb.tcpMetricsByIntervalDaily,+ icmp: tb.icmpMetricsByIntervalDaily,} as const;return { getData: getData[type] };}@@ -166,6 +182,7 @@ export function prepareStatusByPeriod(const getData = {http: tb.httpStatusWeekly,tcp: tb.tcpStatusWeekly,+ icmp: tb.icmpStatusWeekly,} as const;return { getData: getData[type] };}@@ -173,6 +190,7 @@ export function prepareStatusByPeriod(const getData = {http: tb.legacy_httpStatus45d,tcp: tb.legacy_tcpStatus45d,+ icmp: tb.icmpStatus45d,} as const;return { getData: getData[type] };}@@ -180,6 +198,7 @@ export function prepareStatusByPeriod(const getData = {http: tb.httpStatusWeekly,tcp: tb.tcpStatusWeekly,+ icmp: tb.icmpStatusWeekly,} as const;return { getData: getData[type] };}@@ -192,6 +211,7 @@ export function prepareGetByPeriod(period: "30d", type: Type = "http") {const getData = {http: tb.httpGetMonthly,tcp: tb.tcpGetMonthly,+ icmp: tb.icmpGetMonthly,} as const;return { getData: getData[type] };}@@ -199,6 +219,7 @@ export function prepareGetByPeriod(period: "30d", type: Type = "http") {const getData = {http: tb.httpGetMonthly,tcp: tb.tcpGetMonthly,+ icmp: tb.icmpGetMonthly,} as const;return { getData: getData[type] };}diff --git a/apps/workflows/src/cron/checker.ts b/apps/workflows/src/cron/checker.tsindex 73d0dbb11..e39d950b5 100644--- a/apps/workflows/src/cron/checker.ts+++ b/apps/workflows/src/cron/checker.ts@@ -28,6 +28,7 @@ import { regionDict } from "@openstatus/regions";import {type DNSPayloadSchema,type httpPayloadSchema,+ type icmpPayloadSchema,type tpcPayloadSchema,transformHeaders,} from "@openstatus/utils";@@ -285,6 +286,7 @@ const createCronTask = async (| z.infer<typeof httpPayloadSchema>| z.infer<typeof tpcPayloadSchema>| z.infer<typeof DNSPayloadSchema>+ | z.infer<typeof icmpPayloadSchema>| null = null;//@@ -354,6 +356,26 @@ const createCronTask = async (};}+ if (row.jobType === "icmp") {+ payload = {+ workspaceId: String(row.workspaceId),+ monitorId: String(row.id),+ uri: row.url,+ cronTimestamp: timestamp,+ status: status,+ degradedAfter: row.degradedAfter,+ timeout: row.timeout,+ trigger: "cron",+ otelConfig: row.otelEndpoint+ ? {+ endpoint: row.otelEndpoint,+ headers: transformHeaders(row.otelHeaders),+ }+ : undefined,+ retry: row.retry || 3,+ };+ }+if (!payload) {throw new Error("Invalid jobType");}diff --git a/apps/workflows/src/cron/uptime-freeze.ts b/apps/workflows/src/cron/uptime-freeze.tsindex 7a93f8bde..706bb21ea 100644--- a/apps/workflows/src/cron/uptime-freeze.ts+++ b/apps/workflows/src/cron/uptime-freeze.ts@@ -21,6 +21,7 @@ const pipes: UptimeFreezePipes = {http: tb.httpStatus45d,tcp: tb.tcpStatus45d,dns: tb.dnsStatus45d,+ icmp: tb.icmpStatus45d,};export async function handleUptimeFreezeCron(c: Context) {diff --git a/packages/api/src/router/checker.ts b/packages/api/src/router/checker.tsindex f99bfeca0..0e0119127 100644--- a/packages/api/src/router/checker.ts+++ b/packages/api/src/router/checker.ts@@ -13,6 +13,7 @@ import { monitor, selectMonitorSchema } from "@openstatus/db/src/schema";import { monitorRegionSchema } from "@openstatus/db/src/schema/constants";import {type httpPayloadSchema,+ type icmpPayloadSchema,safeUrlSchema,type tpcPayloadSchema,transformHeaders,@@ -25,6 +26,12 @@ import { createTRPCRouter, protectedProcedure } from "../trpc";const ABORT_TIMEOUT = 10000;+// PingICMP treats its timeout as the deadline for the whole check, so omitting+// it means a deadline of "now": the send loop breaks before the first packet+// and every test reports "no reply". Kept under ABORT_TIMEOUT so the checker+// answers before the fetch above gives up.+const ICMP_TEST_TIMEOUT = 5000;+// Input schemasconst httpTestInput = z.object({url: safeUrlSchema,@@ -78,6 +85,37 @@ const dnsTestInput = z.object({.prefault([]),});+const icmpTestInput = z.object({+ url: z.string(),+ region: monitorRegionSchema.optional().prefault("ams"),+});++export const icmpOutput = z+ .object({+ state: z.literal("success").prefault("success"),+ type: z.literal("icmp").prefault("icmp"),+ requestId: z.number().optional(),+ workspaceId: z.number().optional(),+ monitorId: z.number().optional(),+ timestamp: z.number(),+ timing: z.object({+ rtts: z.array(z.number()),+ }),+ latency: z.number().optional(),+ latencyMin: z.number().optional(),+ latencyMax: z.number().optional(),+ packetsSent: z.number().optional(),+ packetsReceived: z.number().optional(),+ error: z.string().optional(),+ region: monitorRegionSchema,+ })+ .or(+ z.object({+ state: z.literal("error").prefault("error"),+ message: z.string(),+ }),+ );+export const tcpOutput = z.object({state: z.literal("success").prefault("success"),@@ -370,12 +408,67 @@ export async function testDns(input: z.infer<typeof dnsTestInput>) {}}+export async function testIcmp(input: z.infer<typeof icmpTestInput>) {+ try {+ const res = await fetch(+ `https://openstatus-checker.fly.dev/icmp/${input.region}`,+ {+ method: "POST",+ headers: {+ Authorization: `Basic ${env.CRON_SECRET}`,+ "Content-Type": "application/json",+ "fly-prefer-region": input.region,+ },+ body: JSON.stringify({+ uri: input.url,+ timeout: ICMP_TEST_TIMEOUT,+ }),+ signal: AbortSignal.timeout(ABORT_TIMEOUT),+ },+ );++ const json = await res.json();+ const result = icmpOutput.safeParse(json);++ if (!result.success) {+ console.error(+ `Checker ICMP test failed for ${input.url}:`,+ result.error.message,+ );+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: `Checker response is not valid. Please try again. If the problem persists, please contact support. ${result.error.message}`,+ });+ }++ if (result.data.state === "error") {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: result.data.message,+ });+ }++ return result.data;+ } catch (error) {+ console.error("Checker ICMP test failed", error);+ if (error instanceof TRPCError) {+ throw error;+ }++ throw new TRPCError({+ code: "INTERNAL_SERVER_ERROR",+ message: "ICMP check failed",+ });+ }+}+export async function triggerChecker(input: z.infer<typeof selectMonitorSchema>,) {let payload:| z.infer<typeof httpPayloadSchema>| z.infer<typeof tpcPayloadSchema>+ | z.infer<typeof icmpPayloadSchema>| null = null;if (process.env.NODE_ENV !== "production") {@@ -450,6 +543,25 @@ export async function triggerChecker(followRedirects: input.followRedirects || true,};}+ if (input.jobType === "icmp") {+ payload = {+ workspaceId: String(input.workspaceId),+ monitorId: String(input.id),+ uri: input.url,+ status: "active",+ cronTimestamp: timestamp,+ degradedAfter: input.degradedAfter,+ timeout: input.timeout,+ trigger: "cron",+ retry: input.retry || 3,+ otelConfig: input.otelEndpoint+ ? {+ endpoint: input.otelEndpoint,+ headers: transformHeaders(input.otelHeaders),+ }+ : undefined,+ };+ }const allResult = [];for (const region of input.regions) {@@ -477,6 +589,8 @@ function generateUrl({ row }: { row: z.infer<typeof selectMonitorSchema> }) {return `https://openstatus-checker.fly.dev/checker/tcp?monitor_id=${row.id}`;case "dns":return `https://openstatus-checker.fly.dev/checker/dns?monitor_id=${row.id}`;+ case "icmp":+ return `https://openstatus-checker.fly.dev/checker/icmp?monitor_id=${row.id}`;default:throw new Error("Invalid jobType");}@@ -502,6 +616,12 @@ export const checkerRouter = createTRPCRouter({.mutation(async ({ input }) => {return testDns(input);}),+ testIcmp: protectedProcedure+ .meta({ track: Events.TestMonitor })+ .input(icmpTestInput)+ .mutation(async ({ input }) => {+ return testIcmp(input);+ }),triggerChecker: protectedProcedure.input(z.object({ id: z.number() }))diff --git a/packages/api/src/router/monitor.ts b/packages/api/src/router/monitor.tsindex 08f0fadfe..a1a5b080c 100644--- a/packages/api/src/router/monitor.ts+++ b/packages/api/src/router/monitor.ts@@ -35,7 +35,7 @@ import { z } from "zod";import { env } from "../env";import { toServiceCtx, toTRPCError } from "../service-adapter";import { createTRPCRouter, protectedProcedure } from "../trpc";-import { testDns, testHttp, testTcp } from "./checker";+import { testDns, testHttp, testIcmp, testTcp } from "./checker";// self-host has no access to the openstatus checker fleet, so the pre-save// endpoint test can never succeed — skip it entirely.@@ -342,6 +342,8 @@ export const monitorRouter = createTRPCRouter({(a) => a.type === "dnsRecord",),});+ } else if (input.jobType === "icmp") {+ await testIcmp({ url: input.url, region: "ams" });}}@@ -406,6 +408,8 @@ export const monitorRouter = createTRPCRouter({(a) => a.type === "dnsRecord",),});+ } else if (input.jobType === "icmp") {+ await testIcmp({ url: input.url, region: "ams" });}}diff --git a/packages/api/src/router/statusPage.ts b/packages/api/src/router/statusPage.tsindex 684acc4b7..c25b4fc2f 100644--- a/packages/api/src/router/statusPage.ts+++ b/packages/api/src/router/statusPage.ts@@ -704,12 +704,14 @@ export const statusPageRouter = createTRPCRouter({http: monitors.filter((c) => c.monitor.jobType === "http"),tcp: monitors.filter((c) => c.monitor.jobType === "tcp"),dns: monitors.filter((c) => c.monitor.jobType === "dns"),+ icmp: monitors.filter((c) => c.monitor.jobType === "icmp"),};const proceduresByType = {http: getStatusProcedure("45d", "http"),tcp: getStatusProcedure("45d", "tcp"),dns: getStatusProcedure("45d", "dns"),+ icmp: getStatusProcedure("45d", "icmp"),};// Manual mode never touches Tinybird. Otherwise race the reads against@@ -717,7 +719,7 @@ export const statusPageRouter = createTRPCRouter({// whole page to manual mode so bars still render from DB events.const tinybird = await withTinybirdFallback(() =>input.barType === "manual"- ? Promise.resolve([null, null, null])+ ? Promise.resolve([null, null, null, null]): Promise.all(Object.entries(proceduresByType).map(([type, procedure]) => {const monitorIds = monitorsByType[@@ -730,7 +732,8 @@ export const statusPageRouter = createTRPCRouter({);const tinybirdUnhealthy = !tinybird.ok;- const [statusHttp, statusTcp, statusDns] = tinybird.data ?? [+ const [statusHttp, statusTcp, statusDns, statusIcmp] = tinybird.data ?? [+ null,null,null,null,@@ -741,10 +744,16 @@ export const statusPageRouter = createTRPCRouter({| Awaited<ReturnType<(typeof proceduresByType)["http"]>>["data"]| Awaited<ReturnType<(typeof proceduresByType)["tcp"]>>["data"]| Awaited<ReturnType<(typeof proceduresByType)["dns"]>>["data"]+ | Awaited<ReturnType<(typeof proceduresByType)["icmp"]>>["data"]>();// Consolidate status data from all monitor types into the map- for (const statusResult of [statusHttp, statusTcp, statusDns]) {+ for (const statusResult of [+ statusHttp,+ statusTcp,+ statusDns,+ statusIcmp,+ ]) {if (statusResult?.data) {statusResult.data.forEach((status) => {const monitorId = status.monitorId;@@ -1010,12 +1019,14 @@ export const statusPageRouter = createTRPCRouter({http: publicMonitors.filter((c) => c.monitor.jobType === "http"),tcp: publicMonitors.filter((c) => c.monitor.jobType === "tcp"),dns: publicMonitors.filter((c) => c.monitor.jobType === "dns"),+ icmp: publicMonitors.filter((c) => c.monitor.jobType === "icmp"),};const proceduresByType = {http: getMetricsLatencyMultiProcedure("1d", "http"),tcp: getMetricsLatencyMultiProcedure("1d", "tcp"),dns: getMetricsLatencyMultiProcedure("1d", "dns"),+ icmp: getMetricsLatencyMultiProcedure("1d", "icmp"),};// Slow/erroring Tinybird → empty latency data so the page still renders.@@ -1035,13 +1046,15 @@ export const statusPageRouter = createTRPCRouter({metricsLatencyMultiHttp,metricsLatencyMultiTcp,metricsLatencyMultiDns,- ] = metrics.data ?? [null, null, null];+ metricsLatencyMultiIcmp,+ ] = metrics.data ?? [null, null, null, null];const metricsDataByMonitorId = new Map<string,| Awaited<ReturnType<(typeof proceduresByType)["http"]>>["data"]| Awaited<ReturnType<(typeof proceduresByType)["tcp"]>>["data"]| Awaited<ReturnType<(typeof proceduresByType)["dns"]>>["data"]+ | Awaited<ReturnType<(typeof proceduresByType)["icmp"]>>["data"]>();if (metricsLatencyMultiHttp?.data) {@@ -1074,6 +1087,16 @@ export const statusPageRouter = createTRPCRouter({});}+ if (metricsLatencyMultiIcmp?.data) {+ metricsLatencyMultiIcmp.data.forEach((metric) => {+ const monitorId = metric.monitorId;+ if (!metricsDataByMonitorId.has(monitorId)) {+ metricsDataByMonitorId.set(monitorId, []);+ }+ metricsDataByMonitorId.get(monitorId)?.push(metric);+ });+ }+return publicMonitors.map((c) => {const monitorId = c.monitor.id.toString();const data = metricsDataByMonitorId.get(monitorId) || [];@@ -1118,7 +1141,7 @@ export const statusPageRouter = createTRPCRouter({if (!_monitor.public) return null;if (_monitor.deletedAt) return null;- const type = _monitor.jobType as "http" | "tcp";+ const type = _monitor.jobType as "http" | "tcp" | "dns" | "icmp";const proceduresByType = {http: {@@ -1136,6 +1159,11 @@ export const statusPageRouter = createTRPCRouter({regions: getMetricsRegionsProcedure("7d", "dns"),uptime: getUptimeProcedure("7d", "dns"),},+ icmp: {+ latency: getMetricsLatencyProcedure("7d", "icmp"),+ regions: getMetricsRegionsProcedure("7d", "icmp"),+ uptime: getUptimeProcedure("7d", "icmp"),+ },};const fromDate = startOfDay(subDays(new Date(), 7)).toISOString();diff --git a/packages/api/src/router/tinybird/index.ts b/packages/api/src/router/tinybird/index.tsindex 9f939c7fe..2e38de876 100644--- a/packages/api/src/router/tinybird/index.ts+++ b/packages/api/src/router/tinybird/index.ts@@ -9,7 +9,7 @@ import { createTRPCRouter, protectedProcedure } from "../../trpc";import { calculatePeriod } from "./utils";const periods = ["1d", "7d", "14d", "30d", "90d"] as const;-const types = ["http", "tcp", "dns"] as const;+const types = ["http", "tcp", "dns", "icmp"] as const;type Period = (typeof periods)[number];type Type = (typeof types)[number];@@ -42,7 +42,9 @@ function clampInterval(period: Period, interval?: number) {// NEW: workspace-level counters helperexport function getWorkspace30dProcedure(type: Type) {- return type === "http" ? tb.httpWorkspace30d : tb.tcpWorkspace30d;+ if (type === "http") return tb.httpWorkspace30d;+ if (type === "icmp") return tb.icmpWorkspace30d;+ return tb.tcpWorkspace30d;}// Helper functions to get the right procedure based on period and typeexport function getListProcedure(period: Period, type: Type) {@@ -51,21 +53,25 @@ export function getListProcedure(period: Period, type: Type) {if (type === "http") return tb.httpListDaily;if (type === "tcp") return tb.tcpListDaily;if (type === "dns") return tb.dnsListBiweekly;+ if (type === "icmp") return tb.icmpListDaily;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "7d":if (type === "http") return tb.httpListWeekly;if (type === "tcp") return tb.tcpListWeekly;if (type === "dns") return tb.dnsListBiweekly;+ if (type === "icmp") return tb.icmpListWeekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "14d":if (type === "http") return tb.httpListBiweekly;if (type === "tcp") return tb.tcpListBiweekly;if (type === "dns") return tb.dnsListBiweekly;+ if (type === "icmp") return tb.icmpListBiweekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });default:if (type === "http") return tb.httpListDaily;if (type === "tcp") return tb.tcpListDaily;if (type === "dns") return tb.dnsListBiweekly;+ if (type === "icmp") return tb.icmpListDaily;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}}@@ -76,31 +82,37 @@ export function getMetricsProcedure(period: Period, type: Type) {if (type === "dns") return tb.dnsMetricsDaily;if (type === "http") return tb.httpMetricsDaily;if (type === "tcp") return tb.tcpMetricsDaily;+ if (type === "icmp") return tb.icmpMetricsDaily;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "7d":if (type === "dns") return tb.dnsMetricsWeekly;if (type === "http") return tb.httpMetricsWeekly;if (type === "tcp") return tb.tcpMetricsWeekly;+ if (type === "icmp") return tb.icmpMetricsWeekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "14d":if (type === "dns") return tb.dnsMetricsBiweekly;if (type === "http") return tb.httpMetricsBiweekly;if (type === "tcp") return tb.tcpMetricsBiweekly;+ if (type === "icmp") return tb.icmpMetricsBiweekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "30d":if (type === "dns") return tb.dnsMetrics30d;if (type === "http") return tb.httpMetrics30d;if (type === "tcp") return tb.tcpMetrics30d;+ if (type === "icmp") return tb.icmpMetrics30d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "90d":if (type === "dns") return tb.dnsMetrics90d;if (type === "http") return tb.httpMetrics90d;if (type === "tcp") return tb.tcpMetrics90d;+ if (type === "icmp") return tb.icmpMetrics90d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });default:if (type === "dns") return tb.dnsMetricsDaily;if (type === "http") return tb.httpMetricsDaily;if (type === "tcp") return tb.tcpMetricsDaily;+ if (type === "icmp") return tb.icmpMetricsDaily;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}}@@ -112,31 +124,37 @@ export function getMetricsRegionsProcedure(period: Period, type: Type) {if (type === "dns") return tb.dnsMetricsRegionsBiweekly;if (type === "http") return tb.httpMetricsRegionsDaily;if (type === "tcp") return tb.tcpMetricsByIntervalDaily;+ if (type === "icmp") return tb.icmpMetricsByIntervalDaily;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "7d":if (type === "dns") return tb.dnsMetricsRegionsBiweekly;if (type === "http") return tb.httpMetricsRegionsWeekly;if (type === "tcp") return tb.tcpMetricsByIntervalWeekly;+ if (type === "icmp") return tb.icmpMetricsByIntervalWeekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "14d":if (type === "dns") return tb.dnsMetricsRegionsBiweekly;if (type === "http") return tb.httpMetricsRegionsBiweekly;if (type === "tcp") return tb.tcpMetricsByIntervalBiweekly;+ if (type === "icmp") return tb.icmpMetricsByIntervalBiweekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "30d":if (type === "dns") return tb.dnsMetricsRegions30d;if (type === "http") return tb.httpMetricsRegions30d;if (type === "tcp") return tb.tcpMetricsByInterval30d;+ if (type === "icmp") return tb.icmpMetricsByInterval30d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "90d":if (type === "dns") return tb.dnsMetricsRegions90d;if (type === "http") return tb.httpMetricsRegions90d;if (type === "tcp") return tb.tcpMetricsByInterval90d;+ if (type === "icmp") return tb.icmpMetricsByInterval90d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });default:if (type === "dns") return tb.dnsMetricsRegionsBiweekly;if (type === "http") return tb.httpMetricsRegionsDaily;if (type === "tcp") return tb.tcpMetricsByIntervalDaily;+ if (type === "icmp") return tb.icmpMetricsByIntervalDaily;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}}@@ -145,6 +163,7 @@ export function getStatusProcedure(_period: "45d", type: Type) {if (type === "dns") return tb.dnsStatus45d;if (type === "http") return tb.httpStatus45d;if (type === "tcp") return tb.tcpStatus45d;+ if (type === "icmp") return tb.icmpStatus45d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}@@ -154,11 +173,13 @@ export function getGetProcedure(period: "14d", type: Type) {if (type === "http") return tb.httpGetBiweekly;if (type === "tcp") return tb.tcpGetBiweekly;if (type === "dns") return tb.dnsGetBiweekly;+ if (type === "icmp") return tb.icmpGetBiweekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });default:if (type === "http") return tb.httpGetBiweekly;if (type === "tcp") return tb.tcpGetBiweekly;if (type === "dns") return tb.dnsGetBiweekly;+ if (type === "icmp") return tb.icmpGetBiweekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}}@@ -167,6 +188,7 @@ export function getGlobalMetricsProcedure(type: Type) {if (type === "http") return tb.httpGlobalMetricsDaily;if (type === "tcp") return tb.tcpGlobalMetricsDaily;if (type === "dns") return tb.dnsGlobalMetricsDaily;+ if (type === "icmp") return tb.icmpGlobalMetricsDaily;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}@@ -177,21 +199,25 @@ export function getUptimeProcedure(period: "7d" | "30d" | "90d", type: Type) {if (type === "dns") return tb.dnsUptime30d;if (type === "http") return tb.httpUptimeWeekly;if (type === "tcp") return tb.tcpUptimeWeekly;+ if (type === "icmp") return tb.icmpUptimeWeekly;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "30d":if (type === "dns") return tb.dnsUptime30d;if (type === "http") return tb.httpUptime30d;if (type === "tcp") return tb.tcpUptime30d;+ if (type === "icmp") return tb.icmpUptime30d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "90d":if (type === "dns") return tb.dnsUptime90d;if (type === "http") return tb.httpUptime90d;if (type === "tcp") return tb.tcpUptime90d;+ if (type === "icmp") return tb.icmpUptime90d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });default:if (type === "dns") return tb.dnsUptime30d;if (type === "http") return tb.httpUptime30d;if (type === "tcp") return tb.tcpUptime30d;+ if (type === "icmp") return tb.icmpUptime30d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}}@@ -203,11 +229,13 @@ export function getMetricsLatencyProcedure(_period: Period, type: Type) {if (type === "dns") return tb.dnsMetricsLatency7d;if (type === "http") return tb.httpMetricsLatency1d;if (type === "tcp") return tb.tcpMetricsLatency1d;+ if (type === "icmp") return tb.icmpMetricsLatency1d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "7d":if (type === "dns") return tb.dnsMetricsLatency7d;if (type === "http") return tb.httpMetricsLatency7d;if (type === "tcp") return tb.tcpMetricsLatency7d;+ if (type === "icmp") return tb.icmpMetricsLatency7d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });// no dedicated 14d latency pipe; 30d MV is the smallest window covering 14dcase "14d":@@ -215,16 +243,19 @@ export function getMetricsLatencyProcedure(_period: Period, type: Type) {if (type === "dns") return tb.dnsMetricsLatency30d;if (type === "http") return tb.httpMetricsLatency30d;if (type === "tcp") return tb.tcpMetricsLatency30d;+ if (type === "icmp") return tb.icmpMetricsLatency30d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });case "90d":if (type === "dns") return tb.dnsMetricsLatency90d;if (type === "http") return tb.httpMetricsLatency90d;if (type === "tcp") return tb.tcpMetricsLatency90d;+ if (type === "icmp") return tb.icmpMetricsLatency90d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });default:if (type === "dns") return tb.dnsMetricsLatency7d;if (type === "http") return tb.httpMetricsLatency1d;if (type === "tcp") return tb.tcpMetricsLatency1d;+ if (type === "icmp") return tb.icmpMetricsLatency1d;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}}@@ -233,6 +264,7 @@ export function getMetricsLatencyMultiProcedure(_period: Period, type: Type) {if (type === "dns") return tb.dnsMetricsLatency1dMulti;if (type === "http") return tb.httpMetricsLatency1dMulti;if (type === "tcp") return tb.tcpMetricsLatency1dMulti;+ if (type === "icmp") return tb.icmpMetricsLatency1dMulti;throw new TRPCError({ code: "NOT_FOUND", message: "Invalid type" });}@@ -280,7 +312,7 @@ export const tinybirdRouter = createTRPCRouter({const procedure = getListProcedure(period,- _monitor.jobType as "http" | "tcp" | "dns",+ _monitor.jobType as "http" | "tcp" | "dns" | "icmp",);return await procedure({...opts.input,@@ -473,7 +505,7 @@ export const tinybirdRouter = createTRPCRouter({const procedure = getGetProcedure(opts.input.period,- _monitor.jobType as "http" | "tcp" | "dns",+ _monitor.jobType as "http" | "tcp" | "dns" | "icmp",);return await procedure(opts.input);}),diff --git a/packages/importers/src/providers/betterstack/mapper.test.ts b/packages/importers/src/providers/betterstack/mapper.test.tsindex 70dfab132..1d805155c 100644--- a/packages/importers/src/providers/betterstack/mapper.test.ts+++ b/packages/importers/src/providers/betterstack/mapper.test.ts@@ -76,6 +76,8 @@ describe("mapMonitorType", () => {expect(mapMonitorType("tcp")).toBe("tcp");expect(mapMonitorType("udp")).toBe("udp");expect(mapMonitorType("dns")).toBe("dns");+ expect(mapMonitorType("ping")).toBe("icmp");+ expect(mapMonitorType("ping_icmp")).toBe("icmp");});test("defaults to http for unknown types", () => {diff --git a/packages/importers/src/providers/betterstack/mapper.ts b/packages/importers/src/providers/betterstack/mapper.tsindex 7dac8c219..4701bdb0c 100644--- a/packages/importers/src/providers/betterstack/mapper.ts+++ b/packages/importers/src/providers/betterstack/mapper.ts@@ -40,8 +40,8 @@ const MONITOR_TYPE_MAP: Record<string, string> = {expected_status_code: "http",tcp: "tcp",udp: "udp",- ping: "http",- ping_icmp: "http",+ ping: "icmp",+ ping_icmp: "icmp",dns: "dns",smtp: "http",pop: "http",diff --git a/packages/proto/api/openstatus/monitor/v1/icmp_monitor.proto b/packages/proto/api/openstatus/monitor/v1/icmp_monitor.protonew file mode 100644index 000000000..0982563a3--- /dev/null+++ b/packages/proto/api/openstatus/monitor/v1/icmp_monitor.proto@@ -0,0 +1,87 @@+syntax = "proto3";++package openstatus.monitor.v1;++import "buf/validate/validate.proto";+import "gnostic/openapi/v3/annotations.proto";+import "openstatus/monitor/v1/http_monitor.proto";+import "openstatus/monitor/v1/monitor.proto";++option go_package = "github.com/openstatushq/openstatus/packages/proto/openstatus/monitor/v1;monitorv1";++// ICMPMonitor defines the configuration for a ICMP monitor.+message ICMPMonitor {+ // Unique identifier for the monitor (output only for create requests).+ string id = 1;++ // Name of the monitor (required, max 256 characters).+ string name = 2 [+ (buf.validate.field).string = {+ min_len: 1+ max_len: 256+ },+ (gnostic.openapi.v3.property) = {example: {yaml: "Ping Gateway"}}+ ];++ // URI to monitor in format "host or IP" (required, max 2048 characters).+ string uri = 3 [+ (buf.validate.field).string = {+ min_len: 1+ max_len: 2048+ },+ (gnostic.openapi.v3.property) = {example: {yaml: "1.1.1.1"}}+ ];++ // Check periodicity (required).+ Periodicity periodicity = 4 [(buf.validate.field).enum = {+ not_in: [0]+ }];++ // Timeout in milliseconds (0-120000, defaults to 45000).+ int64 timeout = 5 [(buf.validate.field).int64 = {+ gte: 0+ lte: 120000+ }];++ // Latency threshold for degraded status in milliseconds (optional, 0-120000).+ optional int64 degraded_at = 6 [(buf.validate.field).int64 = {+ gte: 0+ lte: 120000+ }];++ // Number of retry attempts (0-10, defaults to 3).+ int64 retry = 7 [(buf.validate.field).int64 = {+ gte: 0+ lte: 10+ }];++ // Description of the monitor (optional).+ optional string description = 8 [(buf.validate.field).string.max_len = 1024];++ // Whether the monitor is active (defaults to false).+ optional bool active = 9;++ // Whether the monitor is publicly visible (defaults to false).+ optional bool public = 10;++ // Geographic regions to run checks from.+ repeated Region regions = 11 [(buf.validate.field).repeated = {+ max_items: 28+ items: {+ enum: {+ not_in: [0]+ }+ }+ }];++ // OpenTelemetry configuration for exporting metrics.+ OpenTelemetryConfig open_telemetry = 12;++ // Current operational status of the monitor.+ MonitorStatus status = 13;++ // IDs of private locations that run this monitor. Read-only.+ repeated string private_location_ids = 14 [+ (gnostic.openapi.v3.property) = {read_only: true}+ ];+}diff --git a/packages/proto/api/openstatus/monitor/v1/service.proto b/packages/proto/api/openstatus/monitor/v1/service.protoindex 284664a7c..6ebb97800 100644--- a/packages/proto/api/openstatus/monitor/v1/service.proto+++ b/packages/proto/api/openstatus/monitor/v1/service.proto@@ -6,6 +6,7 @@ import "buf/validate/validate.proto";import "gnostic/openapi/v3/annotations.proto";import "openstatus/monitor/v1/dns_monitor.proto";import "openstatus/monitor/v1/http_monitor.proto";+import "openstatus/monitor/v1/icmp_monitor.proto";import "openstatus/monitor/v1/monitor.proto";import "openstatus/monitor/v1/tcp_monitor.proto";@@ -38,6 +39,9 @@ service MonitorService {// CreateDNSMonitor creates a new DNS monitor.rpc CreateDNSMonitor(CreateDNSMonitorRequest) returns (CreateDNSMonitorResponse);+ // CreateICMPMonitor creates a new ICMP monitor.+ rpc CreateICMPMonitor(CreateICMPMonitorRequest) returns (CreateICMPMonitorResponse);+// UpdateHTTPMonitor updates an existing HTTP monitor.rpc UpdateHTTPMonitor(UpdateHTTPMonitorRequest) returns (UpdateHTTPMonitorResponse);@@ -47,6 +51,9 @@ service MonitorService {// UpdateDNSMonitor updates an existing DNS monitor.rpc UpdateDNSMonitor(UpdateDNSMonitorRequest) returns (UpdateDNSMonitorResponse);+ // UpdateICMPMonitor updates an existing ICMP monitor.+ rpc UpdateICMPMonitor(UpdateICMPMonitorRequest) returns (UpdateICMPMonitorResponse);+// TriggerMonitor initiates an immediate check for a monitor across all configured regions.rpc TriggerMonitor(TriggerMonitorRequest) returns (TriggerMonitorResponse) {option (gnostic.openapi.v3.operation) = {@@ -76,7 +83,7 @@ service MonitorService {}// GetMonitor returns a single monitor by ID within the authenticated workspace.- // Returns the monitor configuration (HTTP, TCP, or DNS) using the MonitorConfig oneof type.+ // Returns the monitor configuration (HTTP, TCP, DNS, or ICMP) using the MonitorConfig oneof type.rpc GetMonitor(GetMonitorRequest) returns (GetMonitorResponse) {option idempotency_level = NO_SIDE_EFFECTS;}@@ -128,6 +135,18 @@ message CreateDNSMonitorResponse {DNSMonitor monitor = 1;}+// CreateICMPMonitorRequest is the request to create a new ICMP monitor.+message CreateICMPMonitorRequest {+ // Monitor configuration (required).+ ICMPMonitor monitor = 1 [(buf.validate.field).required = true];+}++// CreateICMPMonitorResponse is the response after creating an ICMP monitor.+message CreateICMPMonitorResponse {+ // The created monitor with assigned ID.+ ICMPMonitor monitor = 1;+}+// UpdateHTTPMonitorRequest is the request to update an existing HTTP monitor.message UpdateHTTPMonitorRequest {// Monitor ID to update (required).@@ -173,6 +192,21 @@ message UpdateDNSMonitorResponse {DNSMonitor monitor = 1;}+// UpdateICMPMonitorRequest is the request to update an existing ICMP monitor.+message UpdateICMPMonitorRequest {+ // Monitor ID to update (required).+ string id = 1 [(buf.validate.field).string.min_len = 1];++ // Updated monitor configuration (all fields optional for partial updates).+ optional ICMPMonitor monitor = 2;+}++// UpdateICMPMonitorResponse is the response after updating an ICMP monitor.+message UpdateICMPMonitorResponse {+ // The updated monitor.+ ICMPMonitor monitor = 1;+}+// TriggerMonitorRequest is the request to trigger a monitor check.message TriggerMonitorRequest {// Monitor ID to trigger (required).@@ -220,6 +254,9 @@ message ListMonitorsResponse {// DNS monitors in the workspace.repeated DNSMonitor dns_monitors = 3;+ // ICMP monitors in the workspace.+ repeated ICMPMonitor icmp_monitors = 5;+// Total number of monitors across all types.int32 total_size = 4;}@@ -257,6 +294,8 @@ message MonitorConfig {TCPMonitor tcp = 2;// DNS monitor configuration.DNSMonitor dns = 3;+ // ICMP monitor configuration.+ ICMPMonitor icmp = 4;}}@@ -319,7 +358,7 @@ message GetMonitorRequest {// GetMonitorResponse is the response containing the monitor.message GetMonitorResponse {- // The monitor configuration (one of HTTP, TCP, or DNS).+ // The monitor configuration (one of HTTP, TCP, DNS, or ICMP).MonitorConfig monitor = 1;}diff --git a/packages/proto/gen/openapi.yaml b/packages/proto/gen/openapi.yamlindex 507f9fae7..532ee0485 100644--- a/packages/proto/gen/openapi.yaml+++ b/packages/proto/gen/openapi.yaml@@ -470,6 +470,28 @@ components:title: CreateHTTPMonitorResponseadditionalProperties: falsedescription: CreateHTTPMonitorResponse is the response after creating an HTTP monitor.+ openstatus.monitor.v1.CreateICMPMonitorRequest:+ type: object+ properties:+ monitor:+ title: monitor+ description: Monitor configuration (required).+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: CreateICMPMonitorRequest+ required:+ - monitor+ additionalProperties: false+ description: CreateICMPMonitorRequest is the request to create a new ICMP monitor.+ openstatus.monitor.v1.CreateICMPMonitorResponse:+ type: object+ properties:+ monitor:+ title: monitor+ description: The created monitor with assigned ID.+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: CreateICMPMonitorResponse+ additionalProperties: false+ description: CreateICMPMonitorResponse is the response after creating an ICMP monitor.openstatus.monitor.v1.CreateTCPMonitorRequest:type: objectproperties:@@ -665,7 +687,7 @@ components:properties:monitor:title: monitor- description: The monitor configuration (one of HTTP, TCP, or DNS).+ description: The monitor configuration (one of HTTP, TCP, DNS, or ICMP).$ref: '#/components/schemas/openstatus.monitor.v1.MonitorConfig'title: GetMonitorResponseadditionalProperties: false@@ -1189,6 +1211,109 @@ components:title: HeadersadditionalProperties: falsedescription: Headers represents a key-value pair for HTTP headers.+ openstatus.monitor.v1.ICMPMonitor:+ type: object+ properties:+ id:+ type: string+ title: id+ description: Unique identifier for the monitor (output only for create requests).+ name:+ type: string+ examples:+ - Ping Gateway+ title: name+ maxLength: 256+ minLength: 1+ description: Name of the monitor (required, max 256 characters).+ uri:+ type: string+ examples:+ - 1.1.1.1+ title: uri+ maxLength: 2048+ minLength: 1+ description: URI to monitor in format "host or IP" (required, max 2048 characters).+ periodicity:+ not:+ enum:+ - PERIODICITY_UNSPECIFIED+ title: periodicity+ description: Check periodicity (required).+ $ref: '#/components/schemas/openstatus.monitor.v1.Periodicity'+ timeout:+ type:+ - integer+ - string+ title: timeout+ maximum: 120000+ minimum: 0+ format: int64+ description: Timeout in milliseconds (0-120000, defaults to 45000).+ degradedAt:+ type:+ - integer+ - string+ - "null"+ title: degraded_at+ maximum: 120000+ minimum: 0+ format: int64+ description: Latency threshold for degraded status in milliseconds (optional, 0-120000).+ retry:+ type:+ - integer+ - string+ title: retry+ maximum: 10+ minimum: 0+ format: int64+ description: Number of retry attempts (0-10, defaults to 3).+ description:+ type:+ - string+ - "null"+ title: description+ maxLength: 1024+ description: Description of the monitor (optional).+ active:+ type:+ - boolean+ - "null"+ title: active+ description: Whether the monitor is active (defaults to false).+ public:+ type:+ - boolean+ - "null"+ title: public+ description: Whether the monitor is publicly visible (defaults to false).+ regions:+ type: array+ items:+ $ref: '#/components/schemas/openstatus.monitor.v1.Region'+ title: regions+ maxItems: 28+ description: Geographic regions to run checks from.+ openTelemetry:+ title: open_telemetry+ description: OpenTelemetry configuration for exporting metrics.+ $ref: '#/components/schemas/openstatus.monitor.v1.OpenTelemetryConfig'+ status:+ title: status+ description: Current operational status of the monitor.+ $ref: '#/components/schemas/openstatus.monitor.v1.MonitorStatus'+ privateLocationIds:+ type: array+ items:+ type: string+ readOnly: true+ title: private_location_ids+ description: IDs of private locations that run this monitor. Read-only.+ readOnly: true+ title: ICMPMonitor+ additionalProperties: false+ description: ICMPMonitor defines the configuration for a ICMP monitor.openstatus.monitor.v1.ListMonitorHTTPResponseLogsRequest:type: objectproperties:@@ -1293,6 +1418,12 @@ components:$ref: '#/components/schemas/openstatus.monitor.v1.DNSMonitor'title: dns_monitorsdescription: DNS monitors in the workspace.+ icmpMonitors:+ type: array+ items:+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: icmp_monitors+ description: ICMP monitors in the workspace.totalSize:type: integertitle: total_size@@ -1322,6 +1453,15 @@ components:title: httprequired:- http+ - type: object+ properties:+ icmp:+ title: icmp+ description: ICMP monitor configuration.+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: icmp+ required:+ - icmp- type: objectproperties:tcp:@@ -1695,6 +1835,33 @@ components:title: UpdateHTTPMonitorResponseadditionalProperties: falsedescription: UpdateHTTPMonitorResponse is the response after updating an HTTP monitor.+ openstatus.monitor.v1.UpdateICMPMonitorRequest:+ type: object+ properties:+ id:+ type: string+ title: id+ minLength: 1+ description: Monitor ID to update (required).+ monitor:+ oneOf:+ - $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ - type: "null"+ title: monitor+ description: Updated monitor configuration (all fields optional for partial updates).+ title: UpdateICMPMonitorRequest+ additionalProperties: false+ description: UpdateICMPMonitorRequest is the request to update an existing ICMP monitor.+ openstatus.monitor.v1.UpdateICMPMonitorResponse:+ type: object+ properties:+ monitor:+ title: monitor+ description: The updated monitor.+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'+ title: UpdateICMPMonitorResponse+ additionalProperties: false+ description: UpdateICMPMonitorResponse is the response after updating an ICMP monitor.openstatus.monitor.v1.UpdateTCPMonitorRequest:type: objectproperties:@@ -5046,6 +5213,32 @@ paths:application/json:schema:$ref: '#/components/schemas/openstatus.monitor.v1.CreateHTTPMonitorResponse'+ /rpc/openstatus.monitor.v1.MonitorService/CreateICMPMonitor:+ post:+ tags:+ - MonitorService+ summary: CreateICMPMonitor+ description: CreateICMPMonitor creates a new ICMP monitor.+ operationId: MonitorService_CreateICMPMonitor+ requestBody:+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.CreateICMPMonitorRequest'+ required: true+ responses:+ default:+ description: Error+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/connect.error'+ "200":+ description: Success+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.CreateICMPMonitorResponse'/rpc/openstatus.monitor.v1.MonitorService/CreateTCPMonitor:post:tags:@@ -5105,7 +5298,7 @@ paths:summary: GetMonitordescription: |-GetMonitor returns a single monitor by ID within the authenticated workspace.- Returns the monitor configuration (HTTP, TCP, or DNS) using the MonitorConfig oneof type.+ Returns the monitor configuration (HTTP, TCP, DNS, or ICMP) using the MonitorConfig oneof type.operationId: MonitorService_GetMonitor.getparameters:- name: message@@ -5133,7 +5326,7 @@ paths:summary: GetMonitordescription: |-GetMonitor returns a single monitor by ID within the authenticated workspace.- Returns the monitor configuration (HTTP, TCP, or DNS) using the MonitorConfig oneof type.+ Returns the monitor configuration (HTTP, TCP, DNS, or ICMP) using the MonitorConfig oneof type.operationId: MonitorService_GetMonitorrequestBody:content:@@ -5492,6 +5685,32 @@ paths:application/json:schema:$ref: '#/components/schemas/openstatus.monitor.v1.UpdateHTTPMonitorResponse'+ /rpc/openstatus.monitor.v1.MonitorService/UpdateICMPMonitor:+ post:+ tags:+ - MonitorService+ summary: UpdateICMPMonitor+ description: UpdateICMPMonitor updates an existing ICMP monitor.+ operationId: MonitorService_UpdateICMPMonitor+ requestBody:+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.UpdateICMPMonitorRequest'+ required: true+ responses:+ default:+ description: Error+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/connect.error'+ "200":+ description: Success+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/openstatus.monitor.v1.UpdateICMPMonitorResponse'/rpc/openstatus.monitor.v1.MonitorService/UpdateTCPMonitor:post:tags:diff --git a/packages/proto/gen/ts/openstatus/monitor/v1/icmp_monitor_pb.ts b/packages/proto/gen/ts/openstatus/monitor/v1/icmp_monitor_pb.tsnew file mode 100644index 000000000..a05cb46b2--- /dev/null+++ b/packages/proto/gen/ts/openstatus/monitor/v1/icmp_monitor_pb.ts@@ -0,0 +1,132 @@+// @generated by protoc-gen-es v2.12.0 with parameter "target=ts,import_extension=.ts"+// @generated from file openstatus/monitor/v1/icmp_monitor.proto (package openstatus.monitor.v1, syntax proto3)+/* eslint-disable */++import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";+import { file_buf_validate_validate } from "../../../buf/validate/validate_pb.ts";+import { file_gnostic_openapi_v3_annotations } from "../../../gnostic/openapi/v3/annotations_pb.ts";+import type { OpenTelemetryConfig } from "./http_monitor_pb.ts";+import { file_openstatus_monitor_v1_http_monitor } from "./http_monitor_pb.ts";+import type { MonitorStatus, Periodicity, Region } from "./monitor_pb.ts";+import { file_openstatus_monitor_v1_monitor } from "./monitor_pb.ts";+import type { Message } from "@bufbuild/protobuf";++/**+ * Describes the file openstatus/monitor/v1/icmp_monitor.proto.+ */+export const file_openstatus_monitor_v1_icmp_monitor: GenFile = /*@__PURE__*/+ fileDesc("CihvcGVuc3RhdHVzL21vbml0b3IvdjEvaWNtcF9tb25pdG9yLnByb3RvEhVvcGVuc3RhdHVzLm1vbml0b3IudjEi8wQKC0lDTVBNb25pdG9yEgoKAmlkGAEgASgJEisKBG5hbWUYAiABKAlCHbpHEDoOEgxQaW5nIEdhdGV3YXm6SAdyBRABGIACEiUKA3VyaRgDIAEoCUIYukcLOgkSBzEuMS4xLjG6SAdyBRABGIAQEkEKC3BlcmlvZGljaXR5GAQgASgOMiIub3BlbnN0YXR1cy5tb25pdG9yLnYxLlBlcmlvZGljaXR5Qgi6SAWCAQIgABIcCgd0aW1lb3V0GAUgASgDQgu6SAgiBhjAqQcoABIlCgtkZWdyYWRlZF9hdBgGIAEoA0ILukgIIgYYwKkHKABIAIgBARIYCgVyZXRyeRgHIAEoA0IJukgGIgQYCigAEiIKC2Rlc2NyaXB0aW9uGAggASgJQgi6SAVyAxiACEgBiAEBEhMKBmFjdGl2ZRgJIAEoCEgCiAEBEhMKBnB1YmxpYxgKIAEoCEgDiAEBEj8KB3JlZ2lvbnMYCyADKA4yHS5vcGVuc3RhdHVzLm1vbml0b3IudjEuUmVnaW9uQg+6SAySAQkQHCIFggECIAASQgoOb3Blbl90ZWxlbWV0cnkYDCABKAsyKi5vcGVuc3RhdHVzLm1vbml0b3IudjEuT3BlblRlbGVtZXRyeUNvbmZpZxI0CgZzdGF0dXMYDSABKA4yJC5vcGVuc3RhdHVzLm1vbml0b3IudjEuTW9uaXRvclN0YXR1cxIjChRwcml2YXRlX2xvY2F0aW9uX2lkcxgOIAMoCUIFukcCGAFCDgoMX2RlZ3JhZGVkX2F0Qg4KDF9kZXNjcmlwdGlvbkIJCgdfYWN0aXZlQgkKB19wdWJsaWNCU1pRZ2l0aHViLmNvbS9vcGVuc3RhdHVzaHEvb3BlbnN0YXR1cy9wYWNrYWdlcy9wcm90by9vcGVuc3RhdHVzL21vbml0b3IvdjE7bW9uaXRvcnYxYgZwcm90bzM", [file_buf_validate_validate, file_gnostic_openapi_v3_annotations, file_openstatus_monitor_v1_http_monitor, file_openstatus_monitor_v1_monitor]);++/**+ * ICMPMonitor defines the configuration for a ICMP monitor.+ *+ * @generated from message openstatus.monitor.v1.ICMPMonitor+ */+export type ICMPMonitor = Message<"openstatus.monitor.v1.ICMPMonitor"> & {+ /**+ * Unique identifier for the monitor (output only for create requests).+ *+ * @generated from field: string id = 1;+ */+ id: string;++ /**+ * Name of the monitor (required, max 256 characters).+ *+ * @generated from field: string name = 2;+ */+ name: string;++ /**+ * URI to monitor in format "host or IP" (required, max 2048 characters).+ *+ * @generated from field: string uri = 3;+ */+ uri: string;++ /**+ * Check periodicity (required).+ *+ * @generated from field: openstatus.monitor.v1.Periodicity periodicity = 4;+ */+ periodicity: Periodicity;++ /**+ * Timeout in milliseconds (0-120000, defaults to 45000).+ *+ * @generated from field: int64 timeout = 5;+ */+ timeout: bigint;++ /**+ * Latency threshold for degraded status in milliseconds (optional, 0-120000).+ *+ * @generated from field: optional int64 degraded_at = 6;+ */+ degradedAt?: bigint | undefined;++ /**+ * Number of retry attempts (0-10, defaults to 3).+ *+ * @generated from field: int64 retry = 7;+ */+ retry: bigint;++ /**+ * Description of the monitor (optional).+ *+ * @generated from field: optional string description = 8;+ */+ description?: string | undefined;++ /**+ * Whether the monitor is active (defaults to false).+ *+ * @generated from field: optional bool active = 9;+ */+ active?: boolean | undefined;++ /**+ * Whether the monitor is publicly visible (defaults to false).+ *+ * @generated from field: optional bool public = 10;+ */+ public?: boolean | undefined;++ /**+ * Geographic regions to run checks from.+ *+ * @generated from field: repeated openstatus.monitor.v1.Region regions = 11;+ */+ regions: Region[];++ /**+ * OpenTelemetry configuration for exporting metrics.+ *+ * @generated from field: openstatus.monitor.v1.OpenTelemetryConfig open_telemetry = 12;+ */+ openTelemetry?: OpenTelemetryConfig | undefined;++ /**+ * Current operational status of the monitor.+ *+ * @generated from field: openstatus.monitor.v1.MonitorStatus status = 13;+ */+ status: MonitorStatus;++ /**+ * IDs of private locations that run this monitor. Read-only.+ *+ * @generated from field: repeated string private_location_ids = 14;+ */+ privateLocationIds: string[];+};++/**+ * Describes the message openstatus.monitor.v1.ICMPMonitor.+ * Use `create(ICMPMonitorSchema)` to create a new message.+ */+export const ICMPMonitorSchema: GenMessage<ICMPMonitor> = /*@__PURE__*/+ messageDesc(file_openstatus_monitor_v1_icmp_monitor, 0);+diff --git a/packages/proto/gen/ts/openstatus/monitor/v1/index.ts b/packages/proto/gen/ts/openstatus/monitor/v1/index.tsindex d6c08846d..e068ed2ec 100644--- a/packages/proto/gen/ts/openstatus/monitor/v1/index.ts+++ b/packages/proto/gen/ts/openstatus/monitor/v1/index.ts@@ -2,6 +2,7 @@export * from "./assertions_pb.js";export * from "./dns_monitor_pb.js";export * from "./http_monitor_pb.js";+export * from "./icmp_monitor_pb.js";export * from "./tcp_monitor_pb.js";export * from "./monitor_pb.js";export * from "./service_pb.js";diff --git a/packages/proto/gen/ts/openstatus/monitor/v1/service_pb.ts b/packages/proto/gen/ts/openstatus/monitor/v1/service_pb.tsindex 947917338..9de06bc9e 100644--- a/packages/proto/gen/ts/openstatus/monitor/v1/service_pb.ts+++ b/packages/proto/gen/ts/openstatus/monitor/v1/service_pb.ts@@ -10,6 +10,8 @@ import type { DNSMonitor } from "./dns_monitor_pb.ts";import { file_openstatus_monitor_v1_dns_monitor } from "./dns_monitor_pb.ts";import type { HTTPMonitor } from "./http_monitor_pb.ts";import { file_openstatus_monitor_v1_http_monitor } from "./http_monitor_pb.ts";+import type { ICMPMonitor } from "./icmp_monitor_pb.ts";+import { file_openstatus_monitor_v1_icmp_monitor } from "./icmp_monitor_pb.ts";import type { MonitorStatus, Region } from "./monitor_pb.ts";import { file_openstatus_monitor_v1_monitor } from "./monitor_pb.ts";import type { TCPMonitor } from "./tcp_monitor_pb.ts";@@ -20,7 +22,7 @@ import type { Message } from "@bufbuild/protobuf";* Describes the file openstatus/monitor/v1/service.proto.*/export const file_openstatus_monitor_v1_service: GenFile = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_gnostic_openapi_v3_annotations, file_openstatus_monitor_v1_dns_monitor, file_openstatus_monitor_v1_http_monitor, file_openstatus_monitor_v1_monitor, file_openstatus_monitor_v1_tcp_monitor]);+ fileDesc("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", [file_buf_validate_validate, file_gnostic_openapi_v3_annotations, file_openstatus_monitor_v1_dns_monitor, file_openstatus_monitor_v1_http_monitor, file_openstatus_monitor_v1_icmp_monitor, file_openstatus_monitor_v1_monitor, file_openstatus_monitor_v1_tcp_monitor]);/*** CreateHTTPMonitorRequest is the request to create a new HTTP monitor.@@ -148,6 +150,48 @@ export type CreateDNSMonitorResponse = Message<"openstatus.monitor.v1.CreateDNSMexport const CreateDNSMonitorResponseSchema: GenMessage<CreateDNSMonitorResponse> = /*@__PURE__*/messageDesc(file_openstatus_monitor_v1_service, 5);+/**+ * CreateICMPMonitorRequest is the request to create a new ICMP monitor.+ *+ * @generated from message openstatus.monitor.v1.CreateICMPMonitorRequest+ */+export type CreateICMPMonitorRequest = Message<"openstatus.monitor.v1.CreateICMPMonitorRequest"> & {+ /**+ * Monitor configuration (required).+ *+ * @generated from field: openstatus.monitor.v1.ICMPMonitor monitor = 1;+ */+ monitor?: ICMPMonitor | undefined;+};++/**+ * Describes the message openstatus.monitor.v1.CreateICMPMonitorRequest.+ * Use `create(CreateICMPMonitorRequestSchema)` to create a new message.+ */+export const CreateICMPMonitorRequestSchema: GenMessage<CreateICMPMonitorRequest> = /*@__PURE__*/+ messageDesc(file_openstatus_monitor_v1_service, 6);++/**+ * CreateICMPMonitorResponse is the response after creating an ICMP monitor.+ *+ * @generated from message openstatus.monitor.v1.CreateICMPMonitorResponse+ */+export type CreateICMPMonitorResponse = Message<"openstatus.monitor.v1.CreateICMPMonitorResponse"> & {+ /**+ * The created monitor with assigned ID.+ *+ * @generated from field: openstatus.monitor.v1.ICMPMonitor monitor = 1;+ */+ monitor?: ICMPMonitor | undefined;+};++/**+ * Describes the message openstatus.monitor.v1.CreateICMPMonitorResponse.+ * Use `create(CreateICMPMonitorResponseSchema)` to create a new message.+ */+export const CreateICMPMonitorResponseSchema: GenMessage<CreateICMPMonitorResponse> = /*@__PURE__*/+ messageDesc(file_openstatus_monitor_v1_service, 7);+/*** UpdateHTTPMonitorRequest is the request to update an existing HTTP monitor.*@@ -174,7 +218,7 @@ export type UpdateHTTPMonitorRequest = Message<"openstatus.monitor.v1.UpdateHTTP* Use `create(UpdateHTTPMonitorRequestSchema)` to create a new message.*/export const UpdateHTTPMonitorRequestSchema: GenMessage<UpdateHTTPMonitorRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 6);+ messageDesc(file_openstatus_monitor_v1_service, 8);/*** UpdateHTTPMonitorResponse is the response after updating an HTTP monitor.@@ -195,7 +239,7 @@ export type UpdateHTTPMonitorResponse = Message<"openstatus.monitor.v1.UpdateHTT* Use `create(UpdateHTTPMonitorResponseSchema)` to create a new message.*/export const UpdateHTTPMonitorResponseSchema: GenMessage<UpdateHTTPMonitorResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 7);+ messageDesc(file_openstatus_monitor_v1_service, 9);/*** UpdateTCPMonitorRequest is the request to update an existing TCP monitor.@@ -223,7 +267,7 @@ export type UpdateTCPMonitorRequest = Message<"openstatus.monitor.v1.UpdateTCPMo* Use `create(UpdateTCPMonitorRequestSchema)` to create a new message.*/export const UpdateTCPMonitorRequestSchema: GenMessage<UpdateTCPMonitorRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 8);+ messageDesc(file_openstatus_monitor_v1_service, 10);/*** UpdateTCPMonitorResponse is the response after updating a TCP monitor.@@ -244,7 +288,7 @@ export type UpdateTCPMonitorResponse = Message<"openstatus.monitor.v1.UpdateTCPM* Use `create(UpdateTCPMonitorResponseSchema)` to create a new message.*/export const UpdateTCPMonitorResponseSchema: GenMessage<UpdateTCPMonitorResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 9);+ messageDesc(file_openstatus_monitor_v1_service, 11);/*** UpdateDNSMonitorRequest is the request to update an existing DNS monitor.@@ -272,7 +316,7 @@ export type UpdateDNSMonitorRequest = Message<"openstatus.monitor.v1.UpdateDNSMo* Use `create(UpdateDNSMonitorRequestSchema)` to create a new message.*/export const UpdateDNSMonitorRequestSchema: GenMessage<UpdateDNSMonitorRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 10);+ messageDesc(file_openstatus_monitor_v1_service, 12);/*** UpdateDNSMonitorResponse is the response after updating a DNS monitor.@@ -293,7 +337,56 @@ export type UpdateDNSMonitorResponse = Message<"openstatus.monitor.v1.UpdateDNSM* Use `create(UpdateDNSMonitorResponseSchema)` to create a new message.*/export const UpdateDNSMonitorResponseSchema: GenMessage<UpdateDNSMonitorResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 11);+ messageDesc(file_openstatus_monitor_v1_service, 13);++/**+ * UpdateICMPMonitorRequest is the request to update an existing ICMP monitor.+ *+ * @generated from message openstatus.monitor.v1.UpdateICMPMonitorRequest+ */+export type UpdateICMPMonitorRequest = Message<"openstatus.monitor.v1.UpdateICMPMonitorRequest"> & {+ /**+ * Monitor ID to update (required).+ *+ * @generated from field: string id = 1;+ */+ id: string;++ /**+ * Updated monitor configuration (all fields optional for partial updates).+ *+ * @generated from field: optional openstatus.monitor.v1.ICMPMonitor monitor = 2;+ */+ monitor?: ICMPMonitor | undefined;+};++/**+ * Describes the message openstatus.monitor.v1.UpdateICMPMonitorRequest.+ * Use `create(UpdateICMPMonitorRequestSchema)` to create a new message.+ */+export const UpdateICMPMonitorRequestSchema: GenMessage<UpdateICMPMonitorRequest> = /*@__PURE__*/+ messageDesc(file_openstatus_monitor_v1_service, 14);++/**+ * UpdateICMPMonitorResponse is the response after updating an ICMP monitor.+ *+ * @generated from message openstatus.monitor.v1.UpdateICMPMonitorResponse+ */+export type UpdateICMPMonitorResponse = Message<"openstatus.monitor.v1.UpdateICMPMonitorResponse"> & {+ /**+ * The updated monitor.+ *+ * @generated from field: openstatus.monitor.v1.ICMPMonitor monitor = 1;+ */+ monitor?: ICMPMonitor | undefined;+};++/**+ * Describes the message openstatus.monitor.v1.UpdateICMPMonitorResponse.+ * Use `create(UpdateICMPMonitorResponseSchema)` to create a new message.+ */+export const UpdateICMPMonitorResponseSchema: GenMessage<UpdateICMPMonitorResponse> = /*@__PURE__*/+ messageDesc(file_openstatus_monitor_v1_service, 15);/*** TriggerMonitorRequest is the request to trigger a monitor check.@@ -314,7 +407,7 @@ export type TriggerMonitorRequest = Message<"openstatus.monitor.v1.TriggerMonito* Use `create(TriggerMonitorRequestSchema)` to create a new message.*/export const TriggerMonitorRequestSchema: GenMessage<TriggerMonitorRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 12);+ messageDesc(file_openstatus_monitor_v1_service, 16);/*** TriggerMonitorResponse is the response after triggering a monitor.@@ -335,7 +428,7 @@ export type TriggerMonitorResponse = Message<"openstatus.monitor.v1.TriggerMonit* Use `create(TriggerMonitorResponseSchema)` to create a new message.*/export const TriggerMonitorResponseSchema: GenMessage<TriggerMonitorResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 13);+ messageDesc(file_openstatus_monitor_v1_service, 17);/*** DeleteMonitorRequest is the request to delete a monitor.@@ -356,7 +449,7 @@ export type DeleteMonitorRequest = Message<"openstatus.monitor.v1.DeleteMonitorR* Use `create(DeleteMonitorRequestSchema)` to create a new message.*/export const DeleteMonitorRequestSchema: GenMessage<DeleteMonitorRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 14);+ messageDesc(file_openstatus_monitor_v1_service, 18);/*** DeleteMonitorResponse is the response after deleting a monitor.@@ -377,7 +470,7 @@ export type DeleteMonitorResponse = Message<"openstatus.monitor.v1.DeleteMonitor* Use `create(DeleteMonitorResponseSchema)` to create a new message.*/export const DeleteMonitorResponseSchema: GenMessage<DeleteMonitorResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 15);+ messageDesc(file_openstatus_monitor_v1_service, 19);/*** ListMonitorsRequest is the request to list monitors.@@ -405,7 +498,7 @@ export type ListMonitorsRequest = Message<"openstatus.monitor.v1.ListMonitorsReq* Use `create(ListMonitorsRequestSchema)` to create a new message.*/export const ListMonitorsRequestSchema: GenMessage<ListMonitorsRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 16);+ messageDesc(file_openstatus_monitor_v1_service, 20);/*** ListMonitorsResponse is the response containing a list of monitors.@@ -434,6 +527,13 @@ export type ListMonitorsResponse = Message<"openstatus.monitor.v1.ListMonitorsRe*/dnsMonitors: DNSMonitor[];+ /**+ * ICMP monitors in the workspace.+ *+ * @generated from field: repeated openstatus.monitor.v1.ICMPMonitor icmp_monitors = 5;+ */+ icmpMonitors: ICMPMonitor[];+/*** Total number of monitors across all types.*@@ -447,7 +547,7 @@ export type ListMonitorsResponse = Message<"openstatus.monitor.v1.ListMonitorsRe* Use `create(ListMonitorsResponseSchema)` to create a new message.*/export const ListMonitorsResponseSchema: GenMessage<ListMonitorsResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 17);+ messageDesc(file_openstatus_monitor_v1_service, 21);/*** GetMonitorStatusRequest is the request to get the status of all regions for a monitor.@@ -468,7 +568,7 @@ export type GetMonitorStatusRequest = Message<"openstatus.monitor.v1.GetMonitorS* Use `create(GetMonitorStatusRequestSchema)` to create a new message.*/export const GetMonitorStatusRequestSchema: GenMessage<GetMonitorStatusRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 18);+ messageDesc(file_openstatus_monitor_v1_service, 22);/*** RegionStatus represents the status of a monitor in a specific region.@@ -496,7 +596,7 @@ export type RegionStatus = Message<"openstatus.monitor.v1.RegionStatus"> & {* Use `create(RegionStatusSchema)` to create a new message.*/export const RegionStatusSchema: GenMessage<RegionStatus> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 19);+ messageDesc(file_openstatus_monitor_v1_service, 23);/*** GetMonitorStatusResponse is the response containing the status of all regions for a monitor.@@ -524,7 +624,7 @@ export type GetMonitorStatusResponse = Message<"openstatus.monitor.v1.GetMonitor* Use `create(GetMonitorStatusResponseSchema)` to create a new message.*/export const GetMonitorStatusResponseSchema: GenMessage<GetMonitorStatusResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 20);+ messageDesc(file_openstatus_monitor_v1_service, 24);/*** MonitorConfig represents the type-specific configuration for a monitor.@@ -559,6 +659,14 @@ export type MonitorConfig = Message<"openstatus.monitor.v1.MonitorConfig"> & {*/value: DNSMonitor;case: "dns";+ } | {+ /**+ * ICMP monitor configuration.+ *+ * @generated from field: openstatus.monitor.v1.ICMPMonitor icmp = 4;+ */+ value: ICMPMonitor;+ case: "icmp";} | { case: undefined; value?: undefined };};@@ -567,7 +675,7 @@ export type MonitorConfig = Message<"openstatus.monitor.v1.MonitorConfig"> & {* Use `create(MonitorConfigSchema)` to create a new message.*/export const MonitorConfigSchema: GenMessage<MonitorConfig> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 21);+ messageDesc(file_openstatus_monitor_v1_service, 25);/*** GetMonitorSummaryRequest is the request to get aggregated metrics for a monitor.@@ -602,7 +710,7 @@ export type GetMonitorSummaryRequest = Message<"openstatus.monitor.v1.GetMonitor* Use `create(GetMonitorSummaryRequestSchema)` to create a new message.*/export const GetMonitorSummaryRequestSchema: GenMessage<GetMonitorSummaryRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 22);+ messageDesc(file_openstatus_monitor_v1_service, 26);/*** GetMonitorSummaryResponse is the response containing aggregated metrics for a monitor.@@ -700,7 +808,7 @@ export type GetMonitorSummaryResponse = Message<"openstatus.monitor.v1.GetMonito* Use `create(GetMonitorSummaryResponseSchema)` to create a new message.*/export const GetMonitorSummaryResponseSchema: GenMessage<GetMonitorSummaryResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 23);+ messageDesc(file_openstatus_monitor_v1_service, 27);/*** GetMonitorRequest is the request to get a single monitor by ID.@@ -721,7 +829,7 @@ export type GetMonitorRequest = Message<"openstatus.monitor.v1.GetMonitorRequest* Use `create(GetMonitorRequestSchema)` to create a new message.*/export const GetMonitorRequestSchema: GenMessage<GetMonitorRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 24);+ messageDesc(file_openstatus_monitor_v1_service, 28);/*** GetMonitorResponse is the response containing the monitor.@@ -730,7 +838,7 @@ export const GetMonitorRequestSchema: GenMessage<GetMonitorRequest> = /*@__PURE_*/export type GetMonitorResponse = Message<"openstatus.monitor.v1.GetMonitorResponse"> & {/**- * The monitor configuration (one of HTTP, TCP, or DNS).+ * The monitor configuration (one of HTTP, TCP, DNS, or ICMP).** @generated from field: openstatus.monitor.v1.MonitorConfig monitor = 1;*/@@ -742,7 +850,7 @@ export type GetMonitorResponse = Message<"openstatus.monitor.v1.GetMonitorRespon* Use `create(GetMonitorResponseSchema)` to create a new message.*/export const GetMonitorResponseSchema: GenMessage<GetMonitorResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 25);+ messageDesc(file_openstatus_monitor_v1_service, 29);/*** HTTPResponseLogTiming contains calculated timing phases in milliseconds.@@ -791,7 +899,7 @@ export type HTTPResponseLogTiming = Message<"openstatus.monitor.v1.HTTPResponseL* Use `create(HTTPResponseLogTimingSchema)` to create a new message.*/export const HTTPResponseLogTimingSchema: GenMessage<HTTPResponseLogTiming> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 26);+ messageDesc(file_openstatus_monitor_v1_service, 30);/*** HTTPResponseLogListItem is a compact response log entry.@@ -875,7 +983,7 @@ export type HTTPResponseLogListItem = Message<"openstatus.monitor.v1.HTTPRespons* Use `create(HTTPResponseLogListItemSchema)` to create a new message.*/export const HTTPResponseLogListItemSchema: GenMessage<HTTPResponseLogListItem> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 27);+ messageDesc(file_openstatus_monitor_v1_service, 31);/*** HTTPResponseLogDetail contains full response log debugging data.@@ -931,7 +1039,7 @@ export type HTTPResponseLogDetail = Message<"openstatus.monitor.v1.HTTPResponseL* Use `create(HTTPResponseLogDetailSchema)` to create a new message.*/export const HTTPResponseLogDetailSchema: GenMessage<HTTPResponseLogDetail> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 28);+ messageDesc(file_openstatus_monitor_v1_service, 32);/*** ListMonitorHTTPResponseLogsRequest is the request to list response logs within the 14-day HTTP response-log window.@@ -980,7 +1088,7 @@ export type ListMonitorHTTPResponseLogsRequest = Message<"openstatus.monitor.v1.* Use `create(ListMonitorHTTPResponseLogsRequestSchema)` to create a new message.*/export const ListMonitorHTTPResponseLogsRequestSchema: GenMessage<ListMonitorHTTPResponseLogsRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 29);+ messageDesc(file_openstatus_monitor_v1_service, 33);/*** HTTPResponseLogPagination contains offset pagination metadata.@@ -1022,7 +1130,7 @@ export type HTTPResponseLogPagination = Message<"openstatus.monitor.v1.HTTPRespo* Use `create(HTTPResponseLogPaginationSchema)` to create a new message.*/export const HTTPResponseLogPaginationSchema: GenMessage<HTTPResponseLogPagination> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 30);+ messageDesc(file_openstatus_monitor_v1_service, 34);/*** ListMonitorHTTPResponseLogsResponse is the response containing response logs.@@ -1050,7 +1158,7 @@ export type ListMonitorHTTPResponseLogsResponse = Message<"openstatus.monitor.v1* Use `create(ListMonitorHTTPResponseLogsResponseSchema)` to create a new message.*/export const ListMonitorHTTPResponseLogsResponseSchema: GenMessage<ListMonitorHTTPResponseLogsResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 31);+ messageDesc(file_openstatus_monitor_v1_service, 35);/*** GetMonitorHTTPResponseLogRequest is the request to get one response log.@@ -1078,7 +1186,7 @@ export type GetMonitorHTTPResponseLogRequest = Message<"openstatus.monitor.v1.Ge* Use `create(GetMonitorHTTPResponseLogRequestSchema)` to create a new message.*/export const GetMonitorHTTPResponseLogRequestSchema: GenMessage<GetMonitorHTTPResponseLogRequest> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 32);+ messageDesc(file_openstatus_monitor_v1_service, 36);/*** GetMonitorHTTPResponseLogResponse is the response containing one response log.@@ -1099,7 +1207,7 @@ export type GetMonitorHTTPResponseLogResponse = Message<"openstatus.monitor.v1.G* Use `create(GetMonitorHTTPResponseLogResponseSchema)` to create a new message.*/export const GetMonitorHTTPResponseLogResponseSchema: GenMessage<GetMonitorHTTPResponseLogResponse> = /*@__PURE__*/- messageDesc(file_openstatus_monitor_v1_service, 33);+ messageDesc(file_openstatus_monitor_v1_service, 37);/*** TimeRange represents the time period for metrics aggregation.@@ -1253,6 +1361,16 @@ export const MonitorService: GenService<{input: typeof CreateDNSMonitorRequestSchema;output: typeof CreateDNSMonitorResponseSchema;},+ /**+ * CreateICMPMonitor creates a new ICMP monitor.+ *+ * @generated from rpc openstatus.monitor.v1.MonitorService.CreateICMPMonitor+ */+ createICMPMonitor: {+ methodKind: "unary";+ input: typeof CreateICMPMonitorRequestSchema;+ output: typeof CreateICMPMonitorResponseSchema;+ },/*** UpdateHTTPMonitor updates an existing HTTP monitor.*@@ -1283,6 +1401,16 @@ export const MonitorService: GenService<{input: typeof UpdateDNSMonitorRequestSchema;output: typeof UpdateDNSMonitorResponseSchema;},+ /**+ * UpdateICMPMonitor updates an existing ICMP monitor.+ *+ * @generated from rpc openstatus.monitor.v1.MonitorService.UpdateICMPMonitor+ */+ updateICMPMonitor: {+ methodKind: "unary";+ input: typeof UpdateICMPMonitorRequestSchema;+ output: typeof UpdateICMPMonitorResponseSchema;+ },/*** TriggerMonitor initiates an immediate check for a monitor across all configured regions.*@@ -1335,7 +1463,7 @@ export const MonitorService: GenService<{},/*** GetMonitor returns a single monitor by ID within the authenticated workspace.- * Returns the monitor configuration (HTTP, TCP, or DNS) using the MonitorConfig oneof type.+ * Returns the monitor configuration (HTTP, TCP, DNS, or ICMP) using the MonitorConfig oneof type.** @generated from rpc openstatus.monitor.v1.MonitorService.GetMonitor*/diff --git a/packages/proto/internal/private_location/v1/icmp_monitor.proto b/packages/proto/internal/private_location/v1/icmp_monitor.protonew file mode 100644index 000000000..38df2a7b9--- /dev/null+++ b/packages/proto/internal/private_location/v1/icmp_monitor.proto@@ -0,0 +1,22 @@+syntax = "proto3";++package private_location.v1;++import "private_location/v1/otel.proto";++option go_package = "github.com/openstatushq/openstatus/packages/proto/private_location/v1;v1";+++++message ICMPMonitor {+ string id = 1;+ string uri = 2;+ int64 timeout = 3;+ optional int64 degraded_at = 4;+ string periodicity = 5;+ int64 retry = 6;++ OtelConfig otel_config = 20;++}diff --git a/packages/proto/internal/private_location/v1/private_location.proto b/packages/proto/internal/private_location/v1/private_location.protoindex 28ce249c8..b8633c7d9 100644--- a/packages/proto/internal/private_location/v1/private_location.proto+++ b/packages/proto/internal/private_location/v1/private_location.proto@@ -4,6 +4,7 @@ package private_location.v1;import "private_location/v1/dns_monitor.proto";import "private_location/v1/http_monitor.proto";+import "private_location/v1/icmp_monitor.proto";import "private_location/v1/tcp_monitor.proto";@@ -14,6 +15,7 @@ service PrivateLocationService {rpc IngestTCP(IngestTCPRequest) returns (IngestTCPResponse) {}rpc IngestHTTP(IngestHTTPRequest) returns (IngestHTTPResponse) {}rpc IngestDNS(IngestDNSRequest) returns (IngestDNSResponse) {}+ rpc IngestICMP(IngestICMPRequest) returns (IngestICMPResponse) {}}@@ -23,6 +25,7 @@ message MonitorsResponse {repeated HTTPMonitor http_monitors = 1;repeated TCPMonitor tcp_monitors = 2;repeated DNSMonitor dns_monitors = 3;+ repeated ICMPMonitor icmp_monitors = 5;string region = 4;}@@ -85,3 +88,24 @@ message IngestDNSRequest {message IngestDNSResponse {}++message IngestICMPRequest {+ string id = 1;+ string monitorId = 2;+ int64 latency = 3;+ int64 latencyMin = 4;+ int64 latencyMax = 5;+ int64 packetsSent = 6;+ int64 packetsReceived = 7;+ int64 timestamp = 8;+ int64 cronTimestamp = 9;+ string uri = 10;+ string message = 11;+ string requestStatus = 12;+ int64 error = 13;+ string timing = 14;+}++message IngestICMPResponse {++}diff --git a/packages/services/src/frozen-uptime/__tests__/get-history.test.ts b/packages/services/src/frozen-uptime/__tests__/get-history.test.tsindex 4a3f938a5..5335f78ea 100644--- a/packages/services/src/frozen-uptime/__tests__/get-history.test.ts+++ b/packages/services/src/frozen-uptime/__tests__/get-history.test.ts@@ -77,12 +77,12 @@ function fullMonth(function makePipes(rows: ComputeCountRow[]): UptimeFreezePipes {const pipe = () => Promise.resolve({ data: rows });- return { http: pipe, tcp: pipe, dns: pipe };+ return { http: pipe, tcp: pipe, dns: pipe, icmp: pipe };}function failingPipes(): UptimeFreezePipes {const pipe = () => Promise.reject(new Error("tinybird down"));- return { http: pipe, tcp: pipe, dns: pipe };+ return { http: pipe, tcp: pipe, dns: pipe, icmp: pipe };}type Tx = Parameters<Parameters<typeof withTestTransaction>[0]>[0];diff --git a/packages/services/src/frozen-uptime/__tests__/run.test.ts b/packages/services/src/frozen-uptime/__tests__/run.test.tsindex a973fb1de..7c6a3df71 100644--- a/packages/services/src/frozen-uptime/__tests__/run.test.ts+++ b/packages/services/src/frozen-uptime/__tests__/run.test.ts@@ -32,6 +32,7 @@ function makePipes(http: overrides.http ?? fallback,tcp: overrides.tcp ?? fallback,dns: overrides.dns ?? fallback,+ icmp: overrides.icmp ?? fallback,};}@@ -157,7 +158,7 @@ describe("fetchFreezeCounts", () => {const http = okPipe();const { counts, failedMonitorIds } = await fetchFreezeCounts({monitorIdsByJobType: new Map([- ["icmp", new Set(["9"])],+ ["udp", new Set(["9"])],["ssl", new Set(["10"])],]),pipes: makePipes({ http: http.pipe }),diff --git a/packages/services/src/frozen-uptime/get-history.ts b/packages/services/src/frozen-uptime/get-history.tsindex bb4eea2e9..ec1e3fa53 100644--- a/packages/services/src/frozen-uptime/get-history.ts+++ b/packages/services/src/frozen-uptime/get-history.ts@@ -241,6 +241,7 @@ export async function getUptimeHistory(args: {http: defaultTb.httpStatus45d,tcp: defaultTb.tcpStatus45d,dns: defaultTb.dnsStatus45d,+ icmp: defaultTb.icmpStatus45d,};return fetchFreezeCounts({monitorIdsByJobType,diff --git a/packages/services/src/frozen-uptime/run.ts b/packages/services/src/frozen-uptime/run.tsindex 767ba7905..ba66b6a1a 100644--- a/packages/services/src/frozen-uptime/run.ts+++ b/packages/services/src/frozen-uptime/run.ts@@ -19,9 +19,12 @@ export type StatusPipeFn = (params: {monitorIds: string[];}) => Promise<{ data: ComputeCountRow[] }>;-// only these job types have a 45d status pipe; others (icmp/udp/ssl) have no+// only these job types have a 45d status pipe; others (udp/ssl) have no// counts on the live status page either and are skipped-export type UptimeFreezePipes = Record<"http" | "tcp" | "dns", StatusPipeFn>;+export type UptimeFreezePipes = Record<+ "http" | "tcp" | "dns" | "icmp",+ StatusPipeFn+>;export type ChunkFailure = {jobType: string;@@ -53,7 +56,12 @@ function chunk<T>(items: T[], size: number): T[][] {function hasStatusPipe(jobType: string | null | undefined,): jobType is keyof UptimeFreezePipes {- return jobType === "http" || jobType === "tcp" || jobType === "dns";+ return (+ jobType === "http" ||+ jobType === "tcp" ||+ jobType === "dns" ||+ jobType === "icmp"+ );}/**diff --git a/packages/services/src/monitor/__tests__/reads.test.ts b/packages/services/src/monitor/__tests__/reads.test.tsindex 3c7705116..bc4d24d85 100644--- a/packages/services/src/monitor/__tests__/reads.test.ts+++ b/packages/services/src/monitor/__tests__/reads.test.ts@@ -146,13 +146,13 @@ describe("getMonitorSummary", () => {});});- test("throws ValidationError for unsupported jobType (icmp)", async () => {+ test("throws ValidationError for unsupported jobType (udp)", async () => {await withTestTransaction(async (tx) => {const row = await createMonitor({ctx: { ...teamCtx, db: tx },input: {- name: `${TEST_PREFIX}-icmp-summary`,- jobType: "icmp",+ name: `${TEST_PREFIX}-udp-summary`,+ jobType: "udp",url: "1.1.1.1",method: "GET",headers: [],@@ -169,6 +169,29 @@ describe("getMonitorSummary", () => {).rejects.toBeInstanceOf(ValidationError);});});++ test("returns a summary for icmp jobType", async () => {+ await withTestTransaction(async (tx) => {+ const row = await createMonitor({+ ctx: { ...teamCtx, db: tx },+ input: {+ name: `${TEST_PREFIX}-icmp-summary`,+ jobType: "icmp",+ url: "1.1.1.1",+ method: "GET",+ headers: [],+ assertions: [],+ active: false,+ regions: ["ams"],+ },+ });+ const summary = await getMonitorSummary({+ ctx: { ...teamCtx, db: tx },+ input: { monitorId: row.id, timeRange: "1d" },+ });+ expect(summary.monitorId).toBe(row.id);+ });+ });});describe("fetchMonitorDailyStats", () => {@@ -176,6 +199,7 @@ describe("fetchMonitorDailyStats", () => {httpStatus45d: () => Promise.resolve({ data: [] }),tcpStatus45d: () => Promise.resolve({ data: [] }),dnsStatus45d: () => Promise.resolve({ data: [] }),+ icmpStatus45d: () => Promise.resolve({ data: [] }),} as unknown as NonNullable<ServiceContext["tb"]>;test("skips cross-workspace monitorId (returns empty, no throw)", async () => {@@ -215,13 +239,13 @@ describe("fetchMonitorDailyStats", () => {});});- test("skips unsupported jobType (icmp)", async () => {+ test("skips unsupported jobType (udp)", async () => {await withTestTransaction(async (tx) => {const row = await createMonitor({ctx: { ...teamCtx, db: tx },input: {- name: `${TEST_PREFIX}-icmp-daily`,- jobType: "icmp",+ name: `${TEST_PREFIX}-udp-daily`,+ jobType: "udp",url: "1.1.1.1",method: "GET",headers: [],@@ -240,6 +264,48 @@ describe("fetchMonitorDailyStats", () => {});});+ test("queries the icmp pipe for icmp jobType", async () => {+ await withTestTransaction(async (tx) => {+ const row = await createMonitor({+ ctx: { ...teamCtx, db: tx },+ input: {+ name: `${TEST_PREFIX}-icmp-daily`,+ jobType: "icmp",+ url: "1.1.1.1",+ method: "GET",+ headers: [],+ assertions: [],+ active: false,+ regions: ["ams"],+ },+ });+ const icmpTb = {+ httpStatus45d: () => Promise.resolve({ data: [] }),+ tcpStatus45d: () => Promise.resolve({ data: [] }),+ dnsStatus45d: () => Promise.resolve({ data: [] }),+ icmpStatus45d: ({ monitorIds }: { monitorIds: string[] }) =>+ Promise.resolve({+ data: monitorIds.map((monitorId) => ({+ day: "2024-01-01T00:00:00.000Z",+ count: 1,+ ok: 1,+ degraded: 0,+ error: 0,+ monitorId,+ })),+ }),+ } as unknown as NonNullable<ServiceContext["tb"]>;+ const stats = await fetchMonitorDailyStats({+ db: tx,+ tb: icmpTb,+ monitorIds: [row.id],+ workspaceId: teamCtx.workspace.id,+ });+ expect(stats).toHaveLength(1);+ expect(stats[0]?.monitorId).toBe(String(row.id));+ });+ });+test("queries each pipe with its own job type's ids and merges the rows", async () => {await withTestTransaction(async (tx) => {const httpMon = await createMonitor({diff --git a/packages/services/src/monitor/get-daily-summary.ts b/packages/services/src/monitor/get-daily-summary.tsindex 0d8c952ff..00e5eefb4 100644--- a/packages/services/src/monitor/get-daily-summary.ts+++ b/packages/services/src/monitor/get-daily-summary.ts@@ -5,7 +5,7 @@ import type { OSTinybird } from "@openstatus/tinybird";import type { DB } from "../context";import type { StatusData } from "../status-timeline";-type SupportedJobType = "http" | "tcp" | "dns";+type SupportedJobType = "http" | "tcp" | "dns" | "icmp";/*** Raw daily status buckets (one row per monitor per day) from the 45d Tinybird@@ -38,19 +38,21 @@ export async function fetchMonitorDailyStats(args: {http: [],tcp: [],dns: [],+ icmp: [],};for (const row of rows) {if (row.jobType === "http" ||row.jobType === "tcp" ||- row.jobType === "dns"+ row.jobType === "dns" ||+ row.jobType === "icmp") {idsByJobType[row.jobType].push(String(row.id));}}const results = await Promise.all(- (["http", "tcp", "dns"] as const)+ (["http", "tcp", "dns", "icmp"] as const).filter((jobType) => idsByJobType[jobType].length > 0).map((jobType) => {const monitorIds = idsByJobType[jobType];@@ -59,7 +61,9 @@ export async function fetchMonitorDailyStats(args: {? args.tb.httpStatus45d: jobType === "tcp"? args.tb.tcpStatus45d- : args.tb.dnsStatus45d;+ : jobType === "dns"+ ? args.tb.dnsStatus45d+ : args.tb.icmpStatus45d;return pipe({ monitorIds });}),);diff --git a/packages/services/src/monitor/get-monitor-summary.ts b/packages/services/src/monitor/get-monitor-summary.tsindex bef9fe3c8..5345242d4 100644--- a/packages/services/src/monitor/get-monitor-summary.ts+++ b/packages/services/src/monitor/get-monitor-summary.ts@@ -34,7 +34,7 @@ type MetricsRow = {lastTimestamp: number | null;};-type SupportedJobType = "http" | "tcp" | "dns";+type SupportedJobType = "http" | "tcp" | "dns" | "icmp";function fetchMetrics(tb: NonNullable<ServiceContext["tb"]>,@@ -58,6 +58,11 @@ function fetchMetrics("7d": tb.dnsMetricsWeekly,"14d": tb.dnsMetricsBiweekly,},+ icmp: {+ "1d": tb.icmpMetricsDaily,+ "7d": tb.icmpMetricsWeekly,+ "14d": tb.icmpMetricsBiweekly,+ },}[jobType][timeRange];return pipe(params);}@@ -80,7 +85,8 @@ export async function getMonitorSummary(args: {if (parsed.jobType !== "http" &&parsed.jobType !== "tcp" &&- parsed.jobType !== "dns"+ parsed.jobType !== "dns" &&+ parsed.jobType !== "icmp") {throw new ValidationError(`getMonitorSummary does not support jobType '${parsed.jobType}'`,diff --git a/packages/tinybird/datasources/check_icmp_response__v0.datasource b/packages/tinybird/datasources/check_icmp_response__v0.datasourcenew file mode 100644index 000000000..a5c1a9258--- /dev/null+++ b/packages/tinybird/datasources/check_icmp_response__v0.datasource@@ -0,0 +1,21 @@+SCHEMA >+ `monitorId` Int32 `json:$.monitorId`,+ `region` String `json:$.region`,+ `timestamp` Int64 `json:$.timestamp`,+ `cronTimestamp` Int64 `json:$.cronTimestamp`,+ `timing` String `json:$.timing`,+ `latency` Int64 `json:$.latency`,+ `latencyMin` Int64 `json:$.latencyMin`,+ `latencyMax` Int64 `json:$.latencyMax`,+ `packetsSent` UInt8 `json:$.packetsSent`,+ `packetsReceived` UInt8 `json:$.packetsReceived`,+ `errorMessage` Nullable(String) `json:$.errorMessage`,+ `error` Int16 `json:$.error`,+ `trigger` Nullable(String) `json:$.trigger`,+ `uri` Nullable(String) `json:$.uri`,+ `id` Nullable(String) `json:$.id`,+ `requestStatus` Nullable(String) `json:$.requestStatus`,+ `requestId` Int64 `json:$.requestId`++ENGINE "MergeTree"+ENGINE_SORTING_KEY "monitorId, requestId, timestamp"diff --git a/packages/tinybird/datasources/icmp_response__v0.datasource b/packages/tinybird/datasources/icmp_response__v0.datasourcenew file mode 100644index 000000000..9f4b34737--- /dev/null+++ b/packages/tinybird/datasources/icmp_response__v0.datasource@@ -0,0 +1,22 @@+SCHEMA >+ `monitorId` Int32 `json:$.monitorId`,+ `region` String `json:$.region`,+ `timestamp` Int64 `json:$.timestamp`,+ `cronTimestamp` Int64 `json:$.cronTimestamp`,+ `timing` String `json:$.timing`,+ `workspaceId` Int32 `json:$.workspaceId`,+ `latency` Int64 `json:$.latency`,+ `latencyMin` Int64 `json:$.latencyMin`,+ `latencyMax` Int64 `json:$.latencyMax`,+ `packetsSent` UInt8 `json:$.packetsSent`,+ `packetsReceived` UInt8 `json:$.packetsReceived`,+ `errorMessage` Nullable(String) `json:$.errorMessage`,+ `error` Int16 `json:$.error`,+ `trigger` Nullable(String) `json:$.trigger`,+ `uri` Nullable(String) `json:$.uri`,+ `id` Nullable(String) `json:$.id`,+ `requestStatus` Nullable(String) `json:$.requestStatus`++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(fromUnixTimestamp64Milli(cronTimestamp))"+ENGINE_SORTING_KEY "monitorId, cronTimestamp"diff --git a/packages/tinybird/datasources/mv__icmp_14d__v0.datasource b/packages/tinybird/datasources/mv__icmp_14d__v0.datasourcenew file mode 100644index 000000000..c7717ddae--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_14d__v0.datasource@@ -0,0 +1,22 @@+# Data Source created from Pipe 'aggregate__icmp_14d__v0'++SCHEMA >+ `time` DateTime,+ `latency` Int64,+ `latencyMin` Int64,+ `latencyMax` Int64,+ `packetsSent` UInt8,+ `packetsReceived` UInt8,+ `error` Int16,+ `region` String,+ `trigger` Nullable(String),+ `timestamp` Int64,+ `cronTimestamp` Int64,+ `monitorId` Int32,+ `requestStatus` Nullable(String),+ `id` Nullable(String)++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(14)"diff --git a/packages/tinybird/datasources/mv__icmp_1d__v0.datasource b/packages/tinybird/datasources/mv__icmp_1d__v0.datasourcenew file mode 100644index 000000000..f0eb16eaa--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_1d__v0.datasource@@ -0,0 +1,22 @@+# Data Source created from Pipe 'aggregate__icmp_1d__v0'++SCHEMA >+ `time` DateTime,+ `latency` Int64,+ `latencyMin` Int64,+ `latencyMax` Int64,+ `packetsSent` UInt8,+ `packetsReceived` UInt8,+ `error` Int16,+ `region` String,+ `trigger` Nullable(String),+ `timestamp` Int64,+ `cronTimestamp` Int64,+ `monitorId` Int32,+ `requestStatus` Nullable(String),+ `id` Nullable(String)++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(1)"diff --git a/packages/tinybird/datasources/mv__icmp_30d__v0.datasource b/packages/tinybird/datasources/mv__icmp_30d__v0.datasourcenew file mode 100644index 000000000..6a078052c--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_30d__v0.datasource@@ -0,0 +1,22 @@+# Data Source created from Pipe 'aggregate__icmp_30d__v0'++SCHEMA >+ `time` DateTime,+ `latency` Int64,+ `latencyMin` Int64,+ `latencyMax` Int64,+ `packetsSent` UInt8,+ `packetsReceived` UInt8,+ `error` Int16,+ `region` String,+ `trigger` Nullable(String),+ `timestamp` Int64,+ `cronTimestamp` Int64,+ `monitorId` Int32,+ `requestStatus` Nullable(String),+ `id` Nullable(String)++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(30)"diff --git a/packages/tinybird/datasources/mv__icmp_7d__v0.datasource b/packages/tinybird/datasources/mv__icmp_7d__v0.datasourcenew file mode 100644index 000000000..de23c1dfb--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_7d__v0.datasource@@ -0,0 +1,22 @@+# Data Source created from Pipe 'aggregate__icmp_7d__v0'++SCHEMA >+ `time` DateTime,+ `latency` Int64,+ `latencyMin` Int64,+ `latencyMax` Int64,+ `packetsSent` UInt8,+ `packetsReceived` UInt8,+ `error` Int16,+ `region` String,+ `trigger` Nullable(String),+ `timestamp` Int64,+ `cronTimestamp` Int64,+ `monitorId` Int32,+ `requestStatus` Nullable(String),+ `id` Nullable(String)++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(7)"diff --git a/packages/tinybird/datasources/mv__icmp_90d__v0.datasource b/packages/tinybird/datasources/mv__icmp_90d__v0.datasourcenew file mode 100644index 000000000..aabfb87ef--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_90d__v0.datasource@@ -0,0 +1,22 @@+# Data Source created from Pipe 'aggregate__icmp_90d__v0'++SCHEMA >+ `time` DateTime,+ `latency` Int64,+ `latencyMin` Int64,+ `latencyMax` Int64,+ `packetsSent` UInt8,+ `packetsReceived` UInt8,+ `error` Int16,+ `region` String,+ `trigger` Nullable(String),+ `timestamp` Int64,+ `cronTimestamp` Int64,+ `monitorId` Int32,+ `requestStatus` Nullable(String),+ `id` Nullable(String)++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(90)"diff --git a/packages/tinybird/datasources/mv__icmp_full_14d__v0.datasource b/packages/tinybird/datasources/mv__icmp_full_14d__v0.datasourcenew file mode 100644index 000000000..5fb53b61c--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_full_14d__v0.datasource@@ -0,0 +1,26 @@+# Data Source created from Pipe 'aggregate__icmp_full_14d__v0'++SCHEMA >+ `time` DateTime,+ `monitorId` Int32,+ `region` String,+ `timestamp` Int64,+ `cronTimestamp` Int64,+ `timing` String,+ `workspaceId` Int32,+ `latency` Int64,+ `latencyMin` Int64,+ `latencyMax` Int64,+ `packetsSent` UInt8,+ `packetsReceived` UInt8,+ `errorMessage` Nullable(String),+ `error` Int16,+ `trigger` Nullable(String),+ `uri` Nullable(String),+ `id` Nullable(String),+ `requestStatus` Nullable(String)++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(14)"diff --git a/packages/tinybird/datasources/mv__icmp_full_30d__v0.datasource b/packages/tinybird/datasources/mv__icmp_full_30d__v0.datasourcenew file mode 100644index 000000000..5f6514e44--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_full_30d__v0.datasource@@ -0,0 +1,26 @@+# Data Source created from Pipe 'aggregate__icmp_full_30d__v0'++SCHEMA >+ `time` DateTime,+ `monitorId` Int32,+ `region` String,+ `timestamp` Int64,+ `cronTimestamp` Int64,+ `timing` String,+ `workspaceId` Int32,+ `latency` Int64,+ `latencyMin` Int64,+ `latencyMax` Int64,+ `packetsSent` UInt8,+ `packetsReceived` UInt8,+ `errorMessage` Nullable(String),+ `error` Int16,+ `trigger` Nullable(String),+ `uri` Nullable(String),+ `id` Nullable(String),+ `requestStatus` Nullable(String)++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(30)"diff --git a/packages/tinybird/datasources/mv__icmp_status_45d__v0.datasource b/packages/tinybird/datasources/mv__icmp_status_45d__v0.datasourcenew file mode 100644index 000000000..440acac39--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_status_45d__v0.datasource@@ -0,0 +1,14 @@+# Data Source created from Pipe 'aggregate__icmp_status_45d__v0'++SCHEMA >+ `time` DateTime('UTC'),+ `monitorId` Int32,+ `count` AggregateFunction(count),+ `success` AggregateFunction(count, Nullable(UInt8)),+ `error` AggregateFunction(count, Nullable(UInt8)),+ `degraded` AggregateFunction(count, Nullable(UInt8))++ENGINE "AggregatingMergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(46)"diff --git a/packages/tinybird/datasources/mv__icmp_status_7d__v0.datasource b/packages/tinybird/datasources/mv__icmp_status_7d__v0.datasourcenew file mode 100644index 000000000..3813a5256--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_status_7d__v0.datasource@@ -0,0 +1,12 @@+# Data Source created from Pipe 'aggregate__icmp_status_7d__v0'++SCHEMA >+ `time` DateTime('UTC'),+ `monitorId` Int32,+ `count` AggregateFunction(count),+ `ok` AggregateFunction(count, Nullable(UInt8))++ENGINE "AggregatingMergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(7)"diff --git a/packages/tinybird/datasources/mv__icmp_uptime_30d__v0.datasource b/packages/tinybird/datasources/mv__icmp_uptime_30d__v0.datasourcenew file mode 100644index 000000000..1c5602137--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_uptime_30d__v0.datasource@@ -0,0 +1,13 @@+# Data Source created from Pipe 'aggregate__icmp_uptime_30d__v0'++SCHEMA >+ `time` DateTime,+ `region` String,+ `requestStatus` Nullable(String),+ `monitorId` Int32,+ `workspaceId` Int32++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(30)"diff --git a/packages/tinybird/datasources/mv__icmp_uptime_7d__v0.datasource b/packages/tinybird/datasources/mv__icmp_uptime_7d__v0.datasourcenew file mode 100644index 000000000..f255167d8--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_uptime_7d__v0.datasource@@ -0,0 +1,13 @@+# Data Source created from Pipe 'aggregate__icmp_uptime_7d__v0'++SCHEMA >+ `time` DateTime,+ `region` String,+ `requestStatus` Nullable(String),+ `monitorId` Int32,+ `workspaceId` Int32++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(7)"diff --git a/packages/tinybird/datasources/mv__icmp_uptime_90d__v0.datasource b/packages/tinybird/datasources/mv__icmp_uptime_90d__v0.datasourcenew file mode 100644index 000000000..52b205df5--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_uptime_90d__v0.datasource@@ -0,0 +1,13 @@+# Data Source created from Pipe 'aggregate__icmp_uptime_90d__v0'++SCHEMA >+ `time` DateTime,+ `region` String,+ `requestStatus` Nullable(String),+ `monitorId` Int32,+ `workspaceId` Int32++ENGINE "MergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "monitorId, time"+ENGINE_TTL "time + toIntervalDay(90)"diff --git a/packages/tinybird/datasources/mv__icmp_workspace_30d__v0.datasource b/packages/tinybird/datasources/mv__icmp_workspace_30d__v0.datasourcenew file mode 100644index 000000000..b6746934c--- /dev/null+++ b/packages/tinybird/datasources/mv__icmp_workspace_30d__v0.datasource@@ -0,0 +1,12 @@+# Data Source created from Pipe 'aggregate__icmp_workspace_30d__v0'++SCHEMA >+ `time` DateTime('UTC'),+ `workspaceId` Int32,+ `trigger` String,+ `count_state` AggregateFunction(count)++ENGINE "AggregatingMergeTree"+ENGINE_PARTITION_KEY "toYYYYMM(time)"+ENGINE_SORTING_KEY "workspaceId, time, trigger"+ENGINE_TTL "time + toIntervalDay(30)"diff --git a/packages/tinybird/endpoints/endpoint__icmp_get_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_get_14d__v0.pipenew file mode 100644index 000000000..1c88b0d59--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_get_14d__v0.pipe@@ -0,0 +1,15 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT *+ FROM mv__icmp_full_14d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND id = {{ String(id, '', required=True) }}+ ORDER BY time DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_get_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_get_30d__v0.pipenew file mode 100644index 000000000..54bf4e254--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_get_30d__v0.pipe@@ -0,0 +1,15 @@+TAGS "icmp"++NODE endpoint+SQL >++%+ SELECT *+ FROM mv__icmp_full_30d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND cronTimestamp = {{ Int64(cronTimestamp, 1709477432205, required=True) }}+ AND region = {{ String(region, 'ams', required=True) }}+ ORDER BY cronTimestamp DESC++TYPE endpointdiff --git a/packages/tinybird/endpoints/endpoint__icmp_list_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_list_14d__v0.pipenew file mode 100644index 000000000..242cd6ccf--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_list_14d__v0.pipe@@ -0,0 +1,19 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT * FROM mv__icmp_14d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if defined(fromDate) %}+ AND time >= toDateTime(fromUnixTimestamp64Milli(toInt64({{ String(fromDate) }})))+ {% end %}+ {% if defined(toDate) %}+ AND time <= toDateTime(fromUnixTimestamp64Milli(toInt64({{ String(toDate) }})))+ {% end %}+ ORDER BY time DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_list_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_list_1d__v0.pipenew file mode 100644index 000000000..f44a9ba21--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_list_1d__v0.pipe@@ -0,0 +1,19 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT * FROM mv__icmp_1d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if defined(fromDate) %}+ AND time >= toDateTime(fromUnixTimestamp64Milli(toInt64({{ String(fromDate) }})))+ {% end %}+ {% if defined(toDate) %}+ AND time <= toDateTime(fromUnixTimestamp64Milli(toInt64({{ String(toDate) }})))+ {% end %}+ ORDER BY time DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_list_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_list_7d__v0.pipenew file mode 100644index 000000000..803000bd2--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_list_7d__v0.pipe@@ -0,0 +1,19 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT * FROM mv__icmp_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if defined(fromDate) %}+ AND time >= toDateTime(fromUnixTimestamp64Milli(toInt64({{ String(fromDate) }})))+ {% end %}+ {% if defined(toDate) %}+ AND time <= toDateTime(fromUnixTimestamp64Milli(toInt64({{ String(toDate) }})))+ {% end %}+ ORDER BY time DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_14d__v0.pipenew file mode 100644index 000000000..ddf8581e2--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_14d__v0.pipe@@ -0,0 +1,43 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ max(cronTimestamp) AS lastTimestamp+ FROM mv__icmp_14d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 14 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ UNION ALL+ SELECT+ round(quantile(0.50)(latency)) AS p50Latency,+ round(quantile(0.75)(latency)) AS p75Latency,+ round(quantile(0.90)(latency)) AS p90Latency,+ round(quantile(0.95)(latency)) AS p95Latency,+ round(quantile(0.99)(latency)) AS p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ NULL as lastTimestamp -- no need to query the `lastTimestamp` as not relevant+ FROM mv__icmp_30d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 28 DAY, 3)+ AND time < toDateTime64(now() - INTERVAL 14 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_1d__v0.pipenew file mode 100644index 000000000..178bb505b--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_1d__v0.pipe@@ -0,0 +1,43 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ max(cronTimestamp) AS lastTimestamp+ FROM mv__icmp_1d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 1 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ UNION ALL+ SELECT+ round(quantile(0.50)(latency)) AS p50Latency,+ round(quantile(0.75)(latency)) AS p75Latency,+ round(quantile(0.90)(latency)) AS p90Latency,+ round(quantile(0.95)(latency)) AS p95Latency,+ round(quantile(0.99)(latency)) AS p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ NULL as lastTimestamp -- no need to query the `lastTimestamp` as not relevant+ FROM mv__icmp_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 2 DAY, 3)+ AND time < toDateTime64(now() - INTERVAL 1 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_30d__v0.pipenew file mode 100644index 000000000..fe3da8989--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_30d__v0.pipe@@ -0,0 +1,42 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ max(cronTimestamp) AS lastTimestamp+ FROM mv__icmp_30d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 30 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ UNION ALL+ SELECT+ round(quantile(0.50)(latency)) AS p50Latency,+ round(quantile(0.75)(latency)) AS p75Latency,+ round(quantile(0.90)(latency)) AS p90Latency,+ round(quantile(0.95)(latency)) AS p95Latency,+ round(quantile(0.99)(latency)) AS p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ NULL as lastTimestamp+ FROM mv__icmp_90d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 60 DAY, 3)+ AND time < toDateTime64(now() - INTERVAL 30 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_7d__v0.pipenew file mode 100644index 000000000..ab6b9d2f3--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_7d__v0.pipe@@ -0,0 +1,43 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ max(cronTimestamp) AS lastTimestamp+ FROM mv__icmp_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 7 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ UNION ALL+ SELECT+ round(quantile(0.50)(latency)) AS p50Latency,+ round(quantile(0.75)(latency)) AS p75Latency,+ round(quantile(0.90)(latency)) AS p90Latency,+ round(quantile(0.95)(latency)) AS p95Latency,+ round(quantile(0.99)(latency)) AS p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ NULL as lastTimestamp -- no need to query the `lastTimestamp` as not relevant+ FROM mv__icmp_14d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 14 DAY, 3)+ AND time < toDateTime64(now() - INTERVAL 7 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_90d__v0.pipenew file mode 100644index 000000000..0b1d0ccd3--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_90d__v0.pipe@@ -0,0 +1,39 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error,+ max(cronTimestamp) AS lastTimestamp+ FROM mv__icmp_90d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ AND time >= toDateTime64(now() - INTERVAL 90 DAY, 3)+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ UNION ALL+ -- the previous 90d window (90-180d ago) is past the 90d MV TTL, so there's no+ -- real comparison data. emit an empty row to keep the 2-row contract; count 0+ -- makes the client suppress the trend badge (NaN).+ SELECT+ 0 AS p50Latency,+ 0 AS p75Latency,+ 0 AS p90Latency,+ 0 AS p95Latency,+ 0 AS p99Latency,+ 0 AS count,+ 0 AS success,+ 0 AS degraded,+ 0 AS error,+ NULL AS lastTimestamp++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_14d__v0.pipenew file mode 100644index 000000000..879c6c9ea--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_14d__v0.pipe@@ -0,0 +1,28 @@+VERSION 0++TAGS icmp++NODE endpoint+SQL >++ %+ SELECT+ region,+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000),+ INTERVAL {{ Int64(interval, 30) }} MINUTE -- use 2880 (2d) in case you want the 1d summary for the regions+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_14d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h, region+ ORDER BY h DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_1d__v0.pipenew file mode 100644index 000000000..5aee25367--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_1d__v0.pipe@@ -0,0 +1,28 @@+VERSION 0++TAGS icmp++NODE endpoint+SQL >++ %+ SELECT+ region,+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000),+ INTERVAL {{ Int64(interval, 30) }} MINUTE -- use 2880 (2d) in case you want the 1d summary for the regions+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_1d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h, region+ ORDER BY h DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_30d__v0.pipenew file mode 100644index 000000000..094e63903--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_30d__v0.pipe@@ -0,0 +1,26 @@+VERSION 0++TAGS icmp++NODE endpoint+SQL >++ %+ SELECT+ region,+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000), INTERVAL {{ Int64(interval, 1440) }} MINUTE+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_30d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h, region+ ORDER BY h DESC++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_7d__v0.pipenew file mode 100644index 000000000..638bccea4--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_7d__v0.pipe@@ -0,0 +1,28 @@+VERSION 0++TAGS icmp++NODE endpoint+SQL >++ %+ SELECT+ region,+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000),+ INTERVAL {{ Int64(interval, 30) }} MINUTE -- use 2880 (2d) in case you want the 1d summary for the regions+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h, region+ ORDER BY h DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_90d__v0.pipenew file mode 100644index 000000000..b7c788072--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_90d__v0.pipe@@ -0,0 +1,26 @@+VERSION 0++TAGS icmp++NODE endpoint+SQL >++ %+ SELECT+ region,+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000), INTERVAL {{ Int64(interval, 1440) }} MINUTE+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_90d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h, region+ ORDER BY h DESC++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_14d__v0.pipenew file mode 100644index 000000000..384b03395--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_14d__v0.pipe@@ -0,0 +1,22 @@+TAGS "icmp"++NODE endpoint+SQL >++%+ SELECT+ region,+ round(quantile(0.5)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.9)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ count(if(error = 0, 1, NULL)) AS ok+ FROM mv__icmp_14d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ GROUP BY region++TYPE endpointdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_1d__v0.pipenew file mode 100644index 000000000..f4f409acb--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_1d__v0.pipe@@ -0,0 +1,22 @@+TAGS "icmp"++NODE endpoint+SQL >++%+ SELECT+ region,+ round(quantile(0.5)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.9)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ count(if(error = 0, 1, NULL)) AS ok+ FROM mv__icmp_1d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ GROUP BY region++TYPE endpointdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_7d__v0.pipenew file mode 100644index 000000000..d65688cd6--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_7d__v0.pipe@@ -0,0 +1,22 @@+TAGS "icmp"++NODE endpoint+SQL >++%+ SELECT+ region,+ round(quantile(0.5)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.9)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency,+ count() as count,+ count(if(error = 0, 1, NULL)) AS ok+ FROM mv__icmp_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ GROUP BY region++TYPE endpointdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_global_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_global_1d__v0.pipenew file mode 100644index 000000000..2b6e5f9c4--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_global_1d__v0.pipe@@ -0,0 +1,25 @@+VERSION 0++TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ round(min(latency), 0) as minLatency,+ round(max(latency), 0) as maxLatency,+ round(quantile(0.5)(latency), 0) as p50Latency,+ round(quantile(0.75)(latency), 0) as p75Latency,+ round(quantile(0.9)(latency), 0) as p90Latency,+ round(quantile(0.95)(latency), 0) as p95Latency,+ round(quantile(0.99)(latency), 0) as p99Latency,+ max(cronTimestamp) as lastTimestamp,+ count() as count,+ monitorId+ FROM mv__icmp_1d__v0+ WHERE monitorId IN {{ Array(monitorIds, 'String', '4433') }}+ GROUP BY monitorId+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d__v0.pipenew file mode 100644index 000000000..2e00ff92b--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d__v0.pipe@@ -0,0 +1,24 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000), INTERVAL {{ Int64(interval, 30) }} MINUTE+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_1d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h+ ORDER BY h DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d_multi__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d_multi__v0.pipenew file mode 100644index 000000000..c7e82e35c--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d_multi__v0.pipe@@ -0,0 +1,25 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000), INTERVAL {{ Int64(interval, 30) }} MINUTE+ ) as h,+ monitorId,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_1d__v0+ WHERE+ monitorId IN {{ Array(monitorIds, 'String', '4433') }}+ GROUP BY h, monitorId+ ORDER BY h DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_30d__v0.pipenew file mode 100644index 000000000..7b6a79e7e--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_30d__v0.pipe@@ -0,0 +1,23 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000), INTERVAL {{ Int64(interval, 1440) }} MINUTE+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_30d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h+ ORDER BY h DESC++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_7d__v0.pipenew file mode 100644index 000000000..045e47c16--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_7d__v0.pipe@@ -0,0 +1,24 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000), INTERVAL {{ Int64(interval, 30) }} MINUTE+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h+ ORDER BY h DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_90d__v0.pipenew file mode 100644index 000000000..e8c5d4057--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_90d__v0.pipe@@ -0,0 +1,23 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(+ toDateTime(cronTimestamp / 1000), INTERVAL {{ Int64(interval, 1440) }} MINUTE+ ) as h,+ toUnixTimestamp64Milli(toDateTime64(h, 3)) as timestamp,+ round(quantile(0.50)(latency)) as p50Latency,+ round(quantile(0.75)(latency)) as p75Latency,+ round(quantile(0.90)(latency)) as p90Latency,+ round(quantile(0.95)(latency)) as p95Latency,+ round(quantile(0.99)(latency)) as p99Latency+ FROM mv__icmp_90d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ GROUP BY h+ ORDER BY h DESC++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_status_45d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_status_45d__v0.pipenew file mode 100644index 000000000..53593c6b5--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_status_45d__v0.pipe@@ -0,0 +1,20 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ time as day,+ monitorId,+ countMerge(count) as count,+ countMerge(success) as ok,+ countMerge(error) as error,+ countMerge(degraded) as degraded+ FROM mv__icmp_status_45d__v0+ WHERE monitorId IN {{ Array(monitorIds, 'String', '4433') }}+ GROUP BY day, monitorId+ ORDER BY day DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_status_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_status_7d__v0.pipenew file mode 100644index 000000000..1dc9edf50--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_status_7d__v0.pipe@@ -0,0 +1,20 @@+TAGS "icmp"++NODE endpoint+SQL >++%+ SELECT time as day, countMerge(count) as count, countMerge(ok) as ok+ FROM mv__icmp_status_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '1', required=True) }}+ GROUP BY day+ ORDER BY day DESC+ WITH FILL+ FROM+ toStartOfDay(toStartOfDay(toTimeZone(now(), 'UTC')))+ TO toStartOfDay(+ date_sub(DAY, 7, now())+ ) STEP INTERVAL -1 DAY++TYPE endpointdiff --git a/packages/tinybird/endpoints/endpoint__icmp_uptime_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_uptime_30d__v0.pipenew file mode 100644index 000000000..8bada9c99--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_uptime_30d__v0.pipe@@ -0,0 +1,22 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(time, INTERVAL {{ String(interval, '30', required=True) }} minute) AS interval,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error+ FROM mv__icmp_uptime_30d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if fromDate %} AND time >= parseDateTimeBestEffortOrNull({{ String(fromDate) }}) {% end %}+ {% if toDate %} AND time <= parseDateTimeBestEffortOrNull({{ String(toDate) }}) {% end %}+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ GROUP BY interval+ ORDER BY interval DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_uptime_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_uptime_7d__v0.pipenew file mode 100644index 000000000..98673f9bf--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_uptime_7d__v0.pipe@@ -0,0 +1,22 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(time, INTERVAL {{ String(interval, '30', required=True) }} minute) AS interval,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error+ FROM mv__icmp_uptime_7d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if fromDate %} AND time >= parseDateTimeBestEffortOrNull({{ String(fromDate) }}) {% end %}+ {% if toDate %} AND time <= parseDateTimeBestEffortOrNull({{ String(toDate) }}) {% end %}+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ GROUP BY interval+ ORDER BY interval DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_uptime_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_uptime_90d__v0.pipenew file mode 100644index 000000000..c77799c5b--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_uptime_90d__v0.pipe@@ -0,0 +1,21 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ toStartOfInterval(time, INTERVAL {{ String(interval, '1440', required=True) }} minute) AS interval,+ countIf(requestStatus = 'success') AS success,+ countIf(requestStatus = 'degraded') AS degraded,+ countIf(requestStatus = 'error') AS error+ FROM mv__icmp_uptime_90d__v0+ WHERE+ monitorId = {{ String(monitorId, '4433', required=True) }}+ {% if fromDate %} AND time >= parseDateTimeBestEffortOrNull({{ String(fromDate) }}) {% end %}+ {% if toDate %} AND time <= parseDateTimeBestEffortOrNull({{ String(toDate) }}) {% end %}+ {% if regions %} AND region IN {{ Array(regions, 'String', 'ams,fra') }} {% end %}+ GROUP BY interval+ ORDER BY interval DESC++TYPE ENDPOINTdiff --git a/packages/tinybird/endpoints/endpoint__icmp_workspace_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_workspace_30d__v0.pipenew file mode 100644index 000000000..f9b73d399--- /dev/null+++ b/packages/tinybird/endpoints/endpoint__icmp_workspace_30d__v0.pipe@@ -0,0 +1,16 @@+TAGS "icmp"++NODE endpoint+SQL >++ %+ SELECT+ time as day,+ countMerge(count_state) as count+ FROM mv__icmp_workspace_30d__v0+ WHERE workspaceId = {{ Int32(workspaceId, 1, required=True) }}+ GROUP BY day+ ORDER BY day DESC+++TYPE ENDPOINTdiff --git a/packages/tinybird/materializations/aggregate__icmp_full_30d__v0.pipe b/packages/tinybird/materializations/aggregate__icmp_full_30d__v0.pipenew file mode 100644index 000000000..f959a515b--- /dev/null+++ b/packages/tinybird/materializations/aggregate__icmp_full_30d__v0.pipe@@ -0,0 +1,32 @@+DESCRIPTION >+ Stores all the data from the icmp_response table for the last 30 days, mainly used for accessing the data details.+++TAGS "icmp, full"++NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ monitorId,+ region,+ timestamp,+ cronTimestamp,+ timing,+ workspaceId,+ latency,+ latencyMin,+ latencyMax,+ packetsSent,+ packetsReceived,+ errorMessage,+ error,+ trigger,+ uri,+ id,+ requestStatus+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_full_30d__v0diff --git a/packages/tinybird/materializations/aggregate__icmp_status_7d__v0.pipe b/packages/tinybird/materializations/aggregate__icmp_status_7d__v0.pipenew file mode 100644index 000000000..3a491626c--- /dev/null+++ b/packages/tinybird/materializations/aggregate__icmp_status_7d__v0.pipe@@ -0,0 +1,17 @@+TAGS "icmp"++NODE aggregate+SQL >++ SELECT+ toStartOfDay(toTimeZone(fromUnixTimestamp64Milli(cronTimestamp), 'UTC')) AS time,+ monitorId,+ countState() AS count,+ countState(if(error = 0, 1, NULL)) AS ok+ FROM icmp_response__v0+ GROUP BY+ time,+ monitorId++TYPE materialized+DATASOURCE mv__icmp_status_7d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_14d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_14d__v0.pipenew file mode 100644index 000000000..413bde969--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_14d__v0.pipe@@ -0,0 +1,24 @@+TAGS "icmp"++NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ latency,+ latencyMin,+ latencyMax,+ packetsSent,+ packetsReceived,+ error,+ region,+ trigger,+ timestamp,+ cronTimestamp,+ monitorId,+ requestStatus,+ id+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_14d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_1d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_1d__v0.pipenew file mode 100644index 000000000..2f5cd5abf--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_1d__v0.pipe@@ -0,0 +1,24 @@+TAGS "icmp"++NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ latency,+ latencyMin,+ latencyMax,+ packetsSent,+ packetsReceived,+ error,+ region,+ trigger,+ timestamp,+ cronTimestamp,+ monitorId,+ requestStatus,+ id+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_1d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_30d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_30d__v0.pipenew file mode 100644index 000000000..307dc5f4c--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_30d__v0.pipe@@ -0,0 +1,24 @@+TAGS "icmp"++NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ latency,+ latencyMin,+ latencyMax,+ packetsSent,+ packetsReceived,+ error,+ region,+ trigger,+ timestamp,+ cronTimestamp,+ monitorId,+ requestStatus,+ id+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_30d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_7d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_7d__v0.pipenew file mode 100644index 000000000..fd633ff29--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_7d__v0.pipe@@ -0,0 +1,24 @@+TAGS "icmp"++NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ latency,+ latencyMin,+ latencyMax,+ packetsSent,+ packetsReceived,+ error,+ region,+ trigger,+ timestamp,+ cronTimestamp,+ monitorId,+ requestStatus,+ id+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_7d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_90d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_90d__v0.pipenew file mode 100644index 000000000..3a69d8af6--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_90d__v0.pipe@@ -0,0 +1,24 @@+TAGS "icmp"++NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ latency,+ latencyMin,+ latencyMax,+ packetsSent,+ packetsReceived,+ error,+ region,+ trigger,+ timestamp,+ cronTimestamp,+ monitorId,+ requestStatus,+ id+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_90d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_full_14d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_full_14d__v0.pipenew file mode 100644index 000000000..112c8d70c--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_full_14d__v0.pipe@@ -0,0 +1,16 @@+DESCRIPTION >+ Stores all the data from the icmp_response table, mainly used for accessing the data details.+++TAGS "icmp, full"++NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ *+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_full_14d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_status_45d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_status_45d__v0.pipenew file mode 100644index 000000000..f3b10a877--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_status_45d__v0.pipe@@ -0,0 +1,19 @@+TAGS "icmp, statuspage"++NODE aggregate+SQL >++ SELECT+ toStartOfDay(toTimeZone(fromUnixTimestamp64Milli(cronTimestamp), 'UTC')) AS time,+ monitorId,+ countState() AS count,+ countState(if(requestStatus = 'success', 1, NULL)) AS success,+ countState(if(requestStatus = 'error', 1, NULL)) AS error,+ countState(if(requestStatus = 'degraded', 1, NULL)) AS degraded+ FROM icmp_response__v0+ GROUP BY+ time,+ monitorId++TYPE materialized+DATASOURCE mv__icmp_status_45d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_uptime_30d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_uptime_30d__v0.pipenew file mode 100644index 000000000..fab458107--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_uptime_30d__v0.pipe@@ -0,0 +1,13 @@+NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ region,+ requestStatus,+ monitorId,+ workspaceId+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_uptime_30d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_uptime_7d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_uptime_7d__v0.pipenew file mode 100644index 000000000..9b7af2504--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_uptime_7d__v0.pipe@@ -0,0 +1,13 @@+NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ region,+ requestStatus,+ monitorId,+ workspaceId+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_uptime_7d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_uptime_90d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_uptime_90d__v0.pipenew file mode 100644index 000000000..c53a633fd--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_uptime_90d__v0.pipe@@ -0,0 +1,13 @@+NODE aggregate+SQL >++ SELECT+ toDateTime(fromUnixTimestamp64Milli(cronTimestamp)) AS time,+ region,+ requestStatus,+ monitorId,+ workspaceId+ FROM icmp_response__v0++TYPE materialized+DATASOURCE mv__icmp_uptime_90d__v0diff --git a/packages/tinybird/pipes/aggregate__icmp_workspace_30d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_workspace_30d__v0.pipenew file mode 100644index 000000000..936b369b1--- /dev/null+++ b/packages/tinybird/pipes/aggregate__icmp_workspace_30d__v0.pipe@@ -0,0 +1,18 @@+TAGS "icmp"++NODE aggregate+SQL >++ SELECT+ toStartOfDay(toTimeZone(fromUnixTimestamp64Milli(cronTimestamp), 'UTC')) AS time,+ workspaceId,+ ifNull(trigger, 'cron') AS trigger,+ countState() AS count_state+ FROM icmp_response__v0+ GROUP BY+ time,+ workspaceId,+ trigger++TYPE materialized+DATASOURCE mv__icmp_workspace_30d__v0diff --git a/packages/tinybird/src/client.ts b/packages/tinybird/src/client.tsindex 1bff26fb1..a6f434124 100644--- a/packages/tinybird/src/client.ts+++ b/packages/tinybird/src/client.ts@@ -22,6 +22,75 @@ const externalStatusHistoryDailyShape = {snapshot_count: z.int(),};+const icmpMetricsShape = z.object({+ p50Latency: z.number().nullable().prefault(0),+ p75Latency: z.number().nullable().prefault(0),+ p90Latency: z.number().nullable().prefault(0),+ p95Latency: z.number().nullable().prefault(0),+ p99Latency: z.number().nullable().prefault(0),+ count: z.int().prefault(0),+ success: z.int().prefault(0),+ degraded: z.int().prefault(0),+ error: z.int().prefault(0),+ lastTimestamp: z.int().nullable(),+});++const icmpMetricsByIntervalParameters = z.object({+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+ interval: z.int().optional(),+ monitorId: z.string(),+});++const icmpMetricsByIntervalShape = z.object({+ region: z.enum(monitorRegions).or(z.string()),+ timestamp: z.int(),+ p50Latency: z.number().nullable().prefault(0),+ p75Latency: z.number().nullable().prefault(0),+ p90Latency: z.number().nullable().prefault(0),+ p95Latency: z.number().nullable().prefault(0),+ p99Latency: z.number().nullable().prefault(0),+});++const icmpMetricsByRegionParameters = z.object({+ monitorId: z.string(),+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+});++const icmpMetricsByRegionShape = z.object({+ region: z.enum(monitorRegions).or(z.string()),+ count: z.int(),+ ok: z.int(),+ p50Latency: z.number().nullable().prefault(0),+ p75Latency: z.number().nullable().prefault(0),+ p90Latency: z.number().nullable().prefault(0),+ p95Latency: z.number().nullable().prefault(0),+ p99Latency: z.number().nullable().prefault(0),+});++const icmpMetricsLatencyShape = z.object({+ timestamp: z.int(),+ p50Latency: z.int(),+ p75Latency: z.int(),+ p90Latency: z.int(),+ p95Latency: z.int(),+ p99Latency: z.int(),+});++const icmpUptimeParameters = z.object({+ monitorId: z.string(),+ fromDate: z.string().optional(),+ toDate: z.string().optional(),+ regions: z.enum(monitorRegions).or(z.string()).array().optional(),+ interval: z.int().optional(),+});++const icmpUptimeShape = z.object({+ interval: z.coerce.date(),+ success: z.int(),+ degraded: z.int(),+ error: z.int(),+});+export const TINYBIRD_DEFAULT_URL = "https://api.tinybird.co";/**@@ -1178,6 +1247,457 @@ export class OSTinybird {});}+ public get icmpListDaily() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_list_1d__v0",+ parameters: z.object({+ monitorId: z.string(),+ fromDate: z.int().optional(),+ toDate: z.int().optional(),+ }),+ data: z.object({+ type: z.literal("icmp").prefault("icmp"),+ id: z.string().nullable(),+ latency: z.int(),+ latencyMin: z.int().prefault(0),+ latencyMax: z.int().prefault(0),+ packetsSent: z.int().prefault(0),+ packetsReceived: z.int().prefault(0),+ monitorId: z.coerce.string(),+ requestStatus: z.enum(["error", "success", "degraded"]).nullable(),+ region: z.enum(monitorRegions).or(z.string()),+ cronTimestamp: z.int(),+ trigger: z.enum(triggers).nullable().prefault("cron"),+ timestamp: z.number(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpListWeekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_list_7d__v0",+ parameters: z.object({+ monitorId: z.string(),+ fromDate: z.int().optional(),+ toDate: z.int().optional(),+ }),+ data: z.object({+ type: z.literal("icmp").prefault("icmp"),+ id: z.string().nullable(),+ latency: z.int(),+ latencyMin: z.int().prefault(0),+ latencyMax: z.int().prefault(0),+ packetsSent: z.int().prefault(0),+ packetsReceived: z.int().prefault(0),+ monitorId: z.coerce.string(),+ requestStatus: z.enum(["error", "success", "degraded"]).nullable(),+ region: z.enum(monitorRegions).or(z.string()),+ cronTimestamp: z.int(),+ trigger: z.enum(triggers).nullable().prefault("cron"),+ timestamp: z.number(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpListBiweekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_list_14d__v0",+ parameters: z.object({+ monitorId: z.string(),+ fromDate: z.int().optional(),+ toDate: z.int().optional(),+ }),+ data: z.object({+ type: z.literal("icmp").prefault("icmp"),+ id: z.string().nullable(),+ latency: z.int(),+ latencyMin: z.int().prefault(0),+ latencyMax: z.int().prefault(0),+ packetsSent: z.int().prefault(0),+ packetsReceived: z.int().prefault(0),+ monitorId: z.coerce.string(),+ requestStatus: z.enum(["error", "success", "degraded"]).nullable(),+ region: z.enum(monitorRegions).or(z.string()),+ cronTimestamp: z.int(),+ trigger: z.enum(triggers).nullable().prefault("cron"),+ timestamp: z.number(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpGetBiweekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_get_14d__v0",+ parameters: z.object({+ id: z.string().nullable(),+ monitorId: z.string(),+ }),+ data: z.object({+ type: z.literal("icmp").prefault("icmp"),+ id: z.string().nullable(),+ uri: z.string(),+ latency: z.int(),+ latencyMin: z.int().prefault(0),+ latencyMax: z.int().prefault(0),+ packetsSent: z.int().prefault(0),+ packetsReceived: z.int().prefault(0),+ monitorId: z.coerce.string(),+ error: z.coerce.boolean(),+ region: z.enum(monitorRegions).or(z.string()),+ cronTimestamp: z.int(),+ trigger: z.enum(triggers).nullable().prefault("cron"),+ timestamp: z.number(),+ requestStatus: z.enum(["error", "success", "degraded"]).nullable(),+ errorMessage: z.string().nullable(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsDaily() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_1d__v0",+ parameters: z.object({+ interval: z.int().optional(),+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+ monitorId: z.string(),+ }),+ data: icmpMetricsShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsWeekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_7d__v0",+ parameters: z.object({+ interval: z.int().optional(),+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+ monitorId: z.string(),+ }),+ data: icmpMetricsShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsBiweekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_14d__v0",+ parameters: z.object({+ interval: z.int().optional(),+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+ monitorId: z.string(),+ }),+ data: icmpMetricsShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetrics30d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_30d__v0",+ parameters: z.object({+ interval: z.int().optional(),+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+ monitorId: z.string(),+ }),+ data: icmpMetricsShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetrics90d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_90d__v0",+ parameters: z.object({+ interval: z.int().optional(),+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+ monitorId: z.string(),+ }),+ data: icmpMetricsShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByIntervalDaily() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_interval_1d__v0",+ parameters: icmpMetricsByIntervalParameters,+ data: icmpMetricsByIntervalShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByIntervalWeekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_interval_7d__v0",+ parameters: icmpMetricsByIntervalParameters,+ data: icmpMetricsByIntervalShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByIntervalBiweekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_interval_14d__v0",+ parameters: icmpMetricsByIntervalParameters,+ data: icmpMetricsByIntervalShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByInterval30d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_interval_30d__v0",+ parameters: icmpMetricsByIntervalParameters,+ data: icmpMetricsByIntervalShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByInterval90d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_interval_90d__v0",+ parameters: icmpMetricsByIntervalParameters,+ data: icmpMetricsByIntervalShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsLatency1d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_latency_1d__v0",+ parameters: z.object({+ monitorId: z.string(),+ regions: z.array(z.enum(monitorRegions).or(z.string())).optional(),+ fromDate: z.string().optional(),+ toDate: z.string().optional(),+ }),+ data: icmpMetricsLatencyShape,+ });+ }++ public get icmpMetricsLatency7d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_latency_7d__v0",+ parameters: z.object({+ monitorId: z.string(),+ fromDate: z.string().optional(),+ toDate: z.string().optional(),+ }),+ data: icmpMetricsLatencyShape,+ });+ }++ public get icmpMetricsLatency30d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_latency_30d__v0",+ parameters: z.object({+ monitorId: z.string(),+ fromDate: z.string().optional(),+ toDate: z.string().optional(),+ }),+ data: icmpMetricsLatencyShape,+ });+ }++ public get icmpMetricsLatency90d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_latency_90d__v0",+ parameters: z.object({+ monitorId: z.string(),+ fromDate: z.string().optional(),+ toDate: z.string().optional(),+ }),+ data: icmpMetricsLatencyShape,+ });+ }++ public get icmpMetricsLatency1dMulti() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_latency_1d_multi__v0",+ parameters: z.object({+ monitorIds: z.string().array().min(1),+ fromDate: z.string().optional(),+ toDate: z.string().optional(),+ }),+ data: z.object({+ timestamp: z.int(),+ monitorId: z.coerce.string(),+ p50Latency: z.int(),+ p75Latency: z.int(),+ p90Latency: z.int(),+ p95Latency: z.int(),+ p99Latency: z.int(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpStatus45d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_status_45d__v0",+ parameters: z.object({+ monitorIds: z.string().array(),+ days: z.int().max(45).optional(),+ }),+ data: z.object({+ day: z.string().transform((val) => {+ // That's a hack because clickhouse return the date in UTC but in shitty format (2021-09-01 00:00:00)+ return new Date(`${val} GMT`).toISOString();+ }),+ count: z.number().prefault(0),+ ok: z.number().prefault(0),+ degraded: z.number().prefault(0),+ error: z.number().prefault(0),+ monitorId: z.coerce.string(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpUptimeWeekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_uptime_7d__v0",+ parameters: icmpUptimeParameters,+ data: icmpUptimeShape,+ });+ }++ public get icmpUptime30d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_uptime_30d__v0",+ parameters: icmpUptimeParameters,+ data: icmpUptimeShape,+ });+ }++ public get icmpUptime90d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_uptime_90d__v0",+ parameters: icmpUptimeParameters,+ data: icmpUptimeShape,+ });+ }++ public get icmpGlobalMetricsDaily() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_global_1d__v0",+ parameters: z.object({+ monitorIds: z.string().array(),+ }),+ data: z.object({+ minLatency: z.int(),+ maxLatency: z.int(),+ p50Latency: z.int(),+ p75Latency: z.int(),+ p90Latency: z.int(),+ p95Latency: z.int(),+ p99Latency: z.int(),+ lastTimestamp: z.int(),+ count: z.int(),+ monitorId: z.coerce.string(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpWorkspace30d() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_workspace_30d__v0",+ parameters: z.object({+ workspaceId: z.string(),+ }),+ data: z.object({+ day: z+ .string()+ .transform((val) => new Date(`${val} GMT`).toISOString()),+ count: z.int(),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpGetMonthly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_get_30d__v0",+ parameters: z.object({+ monitorId: z.string(),+ region: z.enum(monitorRegions).or(z.string()).optional(),+ cronTimestamp: z.int().optional(),+ }),+ data: z.object({+ type: z.literal("icmp").prefault("icmp"),+ id: z.string().nullable(),+ uri: z.string(),+ latency: z.int(),+ latencyMin: z.int().prefault(0),+ latencyMax: z.int().prefault(0),+ packetsSent: z.int().prefault(0),+ packetsReceived: z.int().prefault(0),+ monitorId: z.coerce.string(),+ error: z.coerce.boolean(),+ region: z.enum(monitorRegions).or(z.string()),+ cronTimestamp: z.int(),+ trigger: z.enum(triggers).nullable().prefault("cron"),+ timestamp: z.number(),+ requestStatus: z.enum(["error", "success", "degraded"]).nullable(),+ errorMessage: z.string().nullable(),+ workspaceId: z.coerce.string(),+ }),+ // REMINDER: cache the result for accessing the data for a check as it won't change+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpStatusWeekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_status_7d__v0",+ parameters: z.object({+ monitorId: z.string(),+ }),+ data: z.object({+ day: z.string().transform((val) => {+ // That's a hack because clickhouse return the date in UTC but in shitty format (2021-09-01 00:00:00)+ return new Date(`${val} GMT`).toISOString();+ }),+ count: z.number().prefault(0),+ ok: z.number().prefault(0),+ }),+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByRegionDaily() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_region_1d__v0",+ parameters: icmpMetricsByRegionParameters,+ data: icmpMetricsByRegionShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByRegionWeekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_region_7d__v0",+ parameters: icmpMetricsByRegionParameters,+ data: icmpMetricsByRegionShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }++ public get icmpMetricsByRegionBiweekly() {+ return this.tb.buildPipe({+ pipe: "endpoint__icmp_metrics_by_region_14d__v0",+ parameters: icmpMetricsByRegionParameters,+ data: icmpMetricsByRegionShape,+ opts: { next: { revalidate: REVALIDATE } },+ });+ }+/*** Region + timestamp metrics (quantiles) – aggregated by interval.* NOTE: The Tinybird pipe returns one row per region & interval with latency quantiles.diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.tsindex 5561ea7dd..ec9a4400e 100644--- a/packages/utils/src/index.ts+++ b/packages/utils/src/index.ts@@ -6,6 +6,8 @@ export {type TcpPayload,DNSPayloadSchema,type DNSPayload,+ icmpPayloadSchema,+ type IcmpPayload,} from "./payloads";export {MONITOR_METHODS,diff --git a/packages/utils/src/payloads.ts b/packages/utils/src/payloads.tsindex c1d412908..e213f4355 100644--- a/packages/utils/src/payloads.ts+++ b/packages/utils/src/payloads.ts@@ -69,3 +69,23 @@ export const DNSPayloadSchema = z.object({});export type DNSPayload = z.infer<typeof DNSPayloadSchema>;++export const icmpPayloadSchema = z.object({+ status: z.enum(MONITOR_STATUSES),+ workspaceId: z.string(),+ uri: z.string(),+ monitorId: z.string(),+ cronTimestamp: z.number(),+ timeout: z.number().prefault(45000),+ degradedAfter: z.number().nullable(),+ trigger: z.enum(["cron", "api"]).optional().nullable().prefault("cron"),+ otelConfig: z+ .object({+ endpoint: z.string(),+ headers: z.record(z.string(), z.string()),+ })+ .optional(),+ retry: z.number().prefault(3),+});++export type IcmpPayload = z.infer<typeof icmpPayloadSchema>;