Skip to content

Open-source status page, incident response and uptime monitoring

icmp check (#2405)

Thibault Le Ouay9643ad610bcf
diff --git a/apps/checker/checker/icmp.go b/apps/checker/checker/icmp.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.mod
index 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.0
go.opentelemetry.io/otel/sdk/log v0.17.0
go.opentelemetry.io/otel/sdk/metric v1.41.0
+ golang.org/x/net v0.51.0
google.golang.org/api v0.269.0
google.golang.org/protobuf v1.36.11
)
@@ -72,7 +73,6 @@ require (
go.opentelemetry.io/proto/otlp v1.9.0 // indirect
golang.org/x/arch v0.24.0 // indirect
golang.org/x/crypto v0.48.0 // indirect
- golang.org/x/net v0.51.0 // indirect
golang.org/x/oauth2 v0.35.0 // indirect
golang.org/x/sync v0.19.0 // indirect
golang.org/x/sys v0.41.0 // indirect
diff --git a/apps/checker/handlers/icmp.go b/apps/checker/handlers/icmp.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 testing
type 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.Inge
func (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.go
new file mode 100644
index 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.go
index 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 stri
connect.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 *conne
return 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, *c
func (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.go
index 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.UnknownFields
sizeCache 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.FileDescriptor
const 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.go
index 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.tsx
index 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.tsx
index 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 monitors
const 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.tsx
index 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 readable
interval: periodToInterval[effectivePeriod],
@@ -144,7 +144,7 @@ export function Client() {
</div>
<GlobalUptimeSection
monitorId={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>
<ChartBarUptime
monitorId={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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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({
<RadioGroup
onValueChange={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.tsx
index 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>
<FormGeneral
defaultValues={{
- 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.tsx
index 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.ts
index 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.md
index 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.go
index 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.go
new file mode 100644
index 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.go
index 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.Requ
if 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 counts
if 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.Requ
HttpMonitors: 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 int
var httpMonitors []*private_locationv1.HTTPMonitor
var tcpMonitors []*private_locationv1.TCPMonitor
var dnsMonitors []*private_locationv1.DNSMonitor
+ var icmpMonitors []*private_locationv1.ICMPMonitor
for _, 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.go
index 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 failures
func 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.go
index 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.go
new file mode 100644
index 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.go
index 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 stri
connect.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 *conne
return 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, *c
func (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.go
index 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.UnknownFields
sizeCache 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.FileDescriptor
const 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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 deleted
const 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 total
expect(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.ts
index 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";
// Regions
diff --git a/apps/server/src/routes/rpc/handlers/monitor/converters/monitors.ts b/apps/server/src/routes/rpc/handlers/monitor/converters/monitors.ts
index 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.ts
index 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.ts
index 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.ts
index 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 to
diff --git a/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts b/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts
index 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.ts
index 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.ts
index 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.pattern
diff --git a/apps/server/src/routes/v1/monitors/run/post.ts b/apps/server/src/routes/v1/monitors/run/post.ts
index 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 region
const monitorStatusData = await db
diff --git a/apps/server/src/routes/v1/monitors/schema.ts b/apps/server/src/routes/v1/monitors/schema.ts
index 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.ts
index 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.ts
index 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 region
const _monitorStatus = await db
diff --git a/apps/server/src/routes/v1/monitors/utils.ts b/apps/server/src/routes/v1/monitors/utils.ts
index 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.yaml
index 507f9fae7..532ee0485 100644
--- a/apps/server/static/openapi.yaml
+++ b/apps/server/static/openapi.yaml
@@ -470,6 +470,28 @@ components:
title: CreateHTTPMonitorResponse
additionalProperties: false
description: 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: object
properties:
@@ -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: GetMonitorResponse
additionalProperties: false
@@ -1189,6 +1211,109 @@ components:
title: Headers
additionalProperties: false
description: 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: object
properties:
@@ -1293,6 +1418,12 @@ components:
$ref: '#/components/schemas/openstatus.monitor.v1.DNSMonitor'
title: dns_monitors
description: 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: integer
title: total_size
@@ -1322,6 +1453,15 @@ components:
title: http
required:
- http
+ - type: object
+ properties:
+ icmp:
+ title: icmp
+ description: ICMP monitor configuration.
+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'
+ title: icmp
+ required:
+ - icmp
- type: object
properties:
tcp:
@@ -1695,6 +1835,33 @@ components:
title: UpdateHTTPMonitorResponse
additionalProperties: false
description: 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: object
properties:
@@ -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: GetMonitor
description: |-
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.get
parameters:
- name: message
@@ -5133,7 +5326,7 @@ paths:
summary: GetMonitor
description: |-
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
requestBody:
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.ts
index 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.mdx
new file mode 100644
index 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.mdx
new file mode 100644
index 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.ts
index 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 periods
const 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 elswhere
type 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.ts
index 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.ts
index 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.ts
index 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 schemas
const 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.ts
index 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.ts
index 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.ts
index 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 helper
export 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 type
export 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 14d
case "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.ts
index 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.ts
index 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.proto
new file mode 100644
index 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.proto
index 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.yaml
index 507f9fae7..532ee0485 100644
--- a/packages/proto/gen/openapi.yaml
+++ b/packages/proto/gen/openapi.yaml
@@ -470,6 +470,28 @@ components:
title: CreateHTTPMonitorResponse
additionalProperties: false
description: 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: object
properties:
@@ -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: GetMonitorResponse
additionalProperties: false
@@ -1189,6 +1211,109 @@ components:
title: Headers
additionalProperties: false
description: 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: object
properties:
@@ -1293,6 +1418,12 @@ components:
$ref: '#/components/schemas/openstatus.monitor.v1.DNSMonitor'
title: dns_monitors
description: 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: integer
title: total_size
@@ -1322,6 +1453,15 @@ components:
title: http
required:
- http
+ - type: object
+ properties:
+ icmp:
+ title: icmp
+ description: ICMP monitor configuration.
+ $ref: '#/components/schemas/openstatus.monitor.v1.ICMPMonitor'
+ title: icmp
+ required:
+ - icmp
- type: object
properties:
tcp:
@@ -1695,6 +1835,33 @@ components:
title: UpdateHTTPMonitorResponse
additionalProperties: false
description: 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: object
properties:
@@ -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: GetMonitor
description: |-
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.get
parameters:
- name: message
@@ -5133,7 +5326,7 @@ paths:
summary: GetMonitor
description: |-
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
requestBody:
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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.CreateDNSM
export 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.proto
new file mode 100644
index 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.proto
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.datasource
new file mode 100644
index 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.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_get_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_get_30d__v0.pipe
new file mode 100644
index 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 endpoint
diff --git a/packages/tinybird/endpoints/endpoint__icmp_list_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_list_14d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_list_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_list_1d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_list_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_list_7d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_14d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_1d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_30d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_7d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_90d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_14d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_1d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_30d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_7d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_interval_90d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_14d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_14d__v0.pipe
new file mode 100644
index 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 endpoint
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_1d__v0.pipe
new file mode 100644
index 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 endpoint
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_by_region_7d__v0.pipe
new file mode 100644
index 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 endpoint
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_global_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_global_1d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d_multi__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_1d_multi__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_30d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_7d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_metrics_latency_90d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_status_45d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_status_45d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_status_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_status_7d__v0.pipe
new file mode 100644
index 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 endpoint
diff --git a/packages/tinybird/endpoints/endpoint__icmp_uptime_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_uptime_30d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_uptime_7d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_uptime_7d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_uptime_90d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_uptime_90d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/endpoints/endpoint__icmp_workspace_30d__v0.pipe b/packages/tinybird/endpoints/endpoint__icmp_workspace_30d__v0.pipe
new file mode 100644
index 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 ENDPOINT
diff --git a/packages/tinybird/materializations/aggregate__icmp_full_30d__v0.pipe b/packages/tinybird/materializations/aggregate__icmp_full_30d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/materializations/aggregate__icmp_status_7d__v0.pipe b/packages/tinybird/materializations/aggregate__icmp_status_7d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_14d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_14d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_1d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_1d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_30d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_30d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_7d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_7d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_90d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_90d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_full_14d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_full_14d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_status_45d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_status_45d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_uptime_30d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_uptime_30d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_uptime_7d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_uptime_7d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_uptime_90d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_uptime_90d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/pipes/aggregate__icmp_workspace_30d__v0.pipe b/packages/tinybird/pipes/aggregate__icmp_workspace_30d__v0.pipe
new file mode 100644
index 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__v0
diff --git a/packages/tinybird/src/client.ts b/packages/tinybird/src/client.ts
index 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.ts
index 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.ts
index 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>;