Skip to content

Open-source status page, incident response and uptime monitoring

🧪 (#1010)

Thibault Le Ouayb1d3d9c7e69e
diff --git a/apps/checker/handlers/checker.go b/apps/checker/handlers/checker.go
index e273cf53b..a57f98a22 100644
--- a/apps/checker/handlers/checker.go
+++ b/apps/checker/handlers/checker.go
@@ -8,10 +8,11 @@ import (
"github.com/cenkalti/backoff/v4"
"github.com/gin-gonic/gin"
+ "github.com/rs/zerolog/log"
+
"github.com/openstatushq/openstatus/apps/checker"
"github.com/openstatushq/openstatus/apps/checker/pkg/assertions"
"github.com/openstatushq/openstatus/apps/checker/request"
- "github.com/rs/zerolog/log"
)
type statusCode int
@@ -134,20 +135,21 @@ func (h Handler) HTTPCheckerHandler(c *gin.Context) {
if err := json.Unmarshal(a, &target); err != nil {
return fmt.Errorf("unable to unmarshal IntTarget: %w", err)
}
- isSuccessfull = isSuccessfull && target.HeaderEvaluate(data.Headers)
+ isSuccessfull = isSuccessfull && target.HeaderEvaluate(data.Headers)
case request.AssertionTextBody:
var target assertions.StringTargetType
if err := json.Unmarshal(a, &target); err != nil {
return fmt.Errorf("unable to unmarshal IntTarget: %w", err)
}
- isSuccessfull = isSuccessfull && target.StringEvaluate(data.Body)
+ isSuccessfull = isSuccessfull && target.StringEvaluate(data.Body)
case request.AssertionStatus:
var target assertions.StatusTarget
if err := json.Unmarshal(a, &target); err != nil {
return fmt.Errorf("unable to unmarshal IntTarget: %w", err)
}
+
isSuccessfull = isSuccessfull && target.StatusEvaluate(int64(res.Status))
case request.AssertionJsonBody:
fmt.Println("assertion type", assert.AssertionType)
@@ -174,7 +176,7 @@ func (h Handler) HTTPCheckerHandler(c *gin.Context) {
}
data.Assertions = assertionAsString
- // That part could be refactored
+
if !isSuccessfull && req.Status == "active" {
// Q: Why here we do not check if the status was previously active?
checker.UpdateStatus(ctx, checker.UpdateData{
diff --git a/apps/checker/handlers/checker_test.go b/apps/checker/handlers/checker_test.go
new file mode 100644
index 000000000..bf16182ad
--- /dev/null
+++ b/apps/checker/handlers/checker_test.go
@@ -0,0 +1,108 @@
+package handlers_test
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+ "github.com/openstatushq/openstatus/apps/checker/handlers"
+ "github.com/openstatushq/openstatus/apps/checker/pkg/tinybird"
+ "github.com/openstatushq/openstatus/apps/checker/request"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestHandler_HTTPCheckerHandler(t *testing.T) {
+ hclient := &http.Client{Transport: RoundTripFunc(func(req *http.Request) *http.Response {
+ return &http.Response{
+ StatusCode: http.StatusAccepted,
+ Body: io.NopCloser(strings.NewReader(`Status Accepted`)),
+ }
+ })}
+ client := tinybird.NewClient(hclient, "apiKey")
+
+ t.Run("it should return 401 if there's no auth", func(t *testing.T) {
+
+ region := "local"
+ h := handlers.Handler{
+ TbClient: client,
+ Secret: "",
+ CloudProvider: "fly",
+ Region: region,
+ }
+ router := gin.New()
+ router.POST("/checker/:region", h.HTTPCheckerHandler)
+
+ w := httptest.NewRecorder()
+
+ data := request.HttpCheckerRequest{
+ URL: "https://www.openstatus.dev",
+ }
+ dataJson, _ := json.Marshal(data)
+ req, _ := http.NewRequest(http.MethodPost, "/checker/"+region, strings.NewReader(string(dataJson)))
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, 401, w.Code)
+ })
+
+ t.Run("it should return 400 if the payload is not ok", func(t *testing.T) {
+ region := "local"
+
+ h := handlers.Handler{
+ TbClient: client,
+ Secret: "test",
+ CloudProvider: "fly",
+ Region: region,
+ }
+ router := gin.New()
+ router.POST("/checker/:region", h.HTTPCheckerHandler)
+
+ w := httptest.NewRecorder()
+
+ data := request.PingRequest{
+ URL: "https://www.openstatus.dev",
+ }
+ dataJson, _ := json.Marshal(data)
+ req, _ := http.NewRequest(http.MethodPost, "/checker/"+region, strings.NewReader(string(dataJson)))
+ req.Header.Set("Authorization", "Basic test")
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, 400, w.Code)
+ assert.Contains(t, w.Body.String(), "{\"error\":\"invalid request\"}")
+ })
+
+ t.Run("it should return 200 if the payload is not ok", func(t *testing.T) {
+ region := "local"
+
+ httptest.NewRequest(http.MethodGet, "http://www.openstatus.dev", nil)
+ httptest.NewRecorder()
+
+ h := handlers.Handler{
+ TbClient: client,
+ Secret: "test",
+ CloudProvider: "fly",
+ Region: region,
+ }
+ router := gin.New()
+ router.POST("/checker/:region", h.HTTPCheckerHandler)
+
+ w := httptest.NewRecorder()
+
+ data := request.HttpCheckerRequest{
+ URL: "https://www.openstatus.dev",
+ Method: "GET",
+ Body: "",
+ }
+ dataJson, _ := json.Marshal(data)
+ req, _ := http.NewRequest(http.MethodPost, "/checker/"+region, strings.NewReader(string(dataJson)))
+ req.Header.Set("Authorization", "Basic test")
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, 200, w.Code)
+ fmt.Println(w.Body.String())
+ })
+}
diff --git a/apps/checker/handlers/handler.go b/apps/checker/handlers/handler.go
index 7f475434d..b8e50f36d 100644
--- a/apps/checker/handlers/handler.go
+++ b/apps/checker/handlers/handler.go
@@ -1,6 +1,8 @@
package handlers
import (
+ "net/http"
+
"github.com/openstatushq/openstatus/apps/checker/pkg/tinybird"
)
@@ -12,3 +14,7 @@ type Handler struct {
}
// Authorization could be handle by middleware
+
+func NewHTTPClient() *http.Client {
+ return &http.Client{}
+}
diff --git a/apps/checker/handlers/ping.go b/apps/checker/handlers/ping.go
index 22e77e15f..a3913512b 100644
--- a/apps/checker/handlers/ping.go
+++ b/apps/checker/handlers/ping.go
@@ -72,6 +72,7 @@ func (h Handler) PingRegionHandler(c *gin.Context) {
requestClient := &http.Client{
Timeout: 45 * time.Second,
}
+
defer requestClient.CloseIdleConnections()
var req request.PingRequest
diff --git a/apps/checker/handlers/ping_test.go b/apps/checker/handlers/ping_test.go
new file mode 100644
index 000000000..e78525da7
--- /dev/null
+++ b/apps/checker/handlers/ping_test.go
@@ -0,0 +1,117 @@
+package handlers_test
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/openstatushq/openstatus/apps/checker/handlers"
+ "github.com/openstatushq/openstatus/apps/checker/pkg/tinybird"
+ "github.com/openstatushq/openstatus/apps/checker/request"
+
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/assert"
+)
+
+type RoundTripFunc func(req *http.Request) *http.Response
+
+func (f RoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+ return f(req), nil
+}
+
+func TestHandler_PingRegion(t *testing.T) {
+
+ hclient := &http.Client{Transport: RoundTripFunc(func(req *http.Request) *http.Response {
+ return &http.Response{
+ StatusCode: http.StatusAccepted,
+ Body: io.NopCloser(strings.NewReader(`Status Accepted`)),
+ }
+ })}
+ client := tinybird.NewClient(hclient, "apiKey")
+
+ t.Run("it should return 401 if there's no auth", func(t *testing.T) {
+
+ region := "local"
+ h := handlers.Handler{
+ TbClient: client,
+ Secret: "",
+ CloudProvider: "fly",
+ Region: region,
+ }
+ router := gin.New()
+ router.POST("/checker/:region", h.PingRegionHandler)
+
+ w := httptest.NewRecorder()
+
+ data := request.PingRequest{
+ URL: "https://www.openstatus.dev",
+ }
+ dataJson, _ := json.Marshal(data)
+ req, _ := http.NewRequest(http.MethodPost, "/checker/"+region, strings.NewReader(string(dataJson)))
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, 401, w.Code)
+ })
+
+ t.Run("it should return 400 if the payload is not ok", func(t *testing.T) {
+ region := "local"
+
+ h := handlers.Handler{
+ TbClient: client,
+ Secret: "test",
+ CloudProvider: "fly",
+ Region: region,
+ }
+ router := gin.New()
+ router.POST("/checker/:region", h.PingRegionHandler)
+
+ w := httptest.NewRecorder()
+
+ data := request.HttpCheckerRequest{
+ URL: "https://www.openstatus.dev",
+ }
+ dataJson, _ := json.Marshal(data)
+ req, _ := http.NewRequest(http.MethodPost, "/checker/"+region, strings.NewReader(string(dataJson)))
+ req.Header.Set("Authorization", "Basic test")
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, 400, w.Code)
+ assert.Contains(t, w.Body.String(), "{\"error\":\"invalid request\"}")
+ })
+
+ t.Run("it should return 200 if the payload is ok", func(t *testing.T) {
+ region := "local"
+
+ httptest.NewRequest(http.MethodGet, "http://www.openstatus.dev", nil)
+ httptest.NewRecorder()
+
+ h := handlers.Handler{
+ TbClient: client,
+ Secret: "test",
+ CloudProvider: "fly",
+ Region: region,
+ }
+ router := gin.New()
+ router.POST("/checker/:region", h.PingRegionHandler)
+
+ w := httptest.NewRecorder()
+
+ data := request.PingRequest{
+ URL: "https://www.openstatus.dev",
+ Method: "GET",
+ Headers: map[string]string{},
+ Body: "",
+ }
+ dataJson, _ := json.Marshal(data)
+ req, _ := http.NewRequest(http.MethodPost, "/checker/"+region, strings.NewReader(string(dataJson)))
+ req.Header.Set("Authorization", "Basic test")
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, 200, w.Code)
+ fmt.Println(w.Body.String())
+ })
+}
diff --git a/apps/checker/handlers/tcp.go b/apps/checker/handlers/tcp.go
index 16eb8aff8..80932e0d2 100644
--- a/apps/checker/handlers/tcp.go
+++ b/apps/checker/handlers/tcp.go
@@ -25,8 +25,10 @@ type TCPResponse struct {
func (h Handler) TCPHandler(c *gin.Context) {
ctx := c.Request.Context()
dataSourceName := "tcp_response__v0"
+
if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", h.Secret) {
c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
+
return
}
@@ -36,23 +38,30 @@ func (h Handler) TCPHandler(c *gin.Context) {
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.TCPCheckerRequest
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
}
@@ -60,6 +69,7 @@ func (h Handler) TCPHandler(c *gin.Context) {
op := func() error {
called++
res, err := checker.PingTcp(int(req.Timeout), req.URL)
+
if err != nil {
return fmt.Errorf("unable to check tcp %s", err)
}
@@ -75,6 +85,7 @@ func (h Handler) TCPHandler(c *gin.Context) {
MonitorID: monitorId,
}
latency := res.TCPDone - res.TCPStart
+
if req.Status == "active" && req.DegradedAfter > 0 && latency > req.DegradedAfter {
checker.UpdateStatus(ctx, checker.UpdateData{
MonitorId: req.MonitorID,
@@ -83,6 +94,7 @@ func (h Handler) TCPHandler(c *gin.Context) {
CronTimestamp: req.CronTimestamp,
})
}
+
if req.Status == "degraded" && req.DegradedAfter > 0 && latency <= req.DegradedAfter {
checker.UpdateStatus(ctx, checker.UpdateData{
MonitorId: req.MonitorID,
@@ -129,6 +141,7 @@ func (h Handler) TCPHandler(c *gin.Context) {
})
}
}
+
c.JSON(http.StatusOK, gin.H{"message": "ok"})
}
diff --git a/apps/checker/http_test.go b/apps/checker/http_test.go
index 664b23637..c0dba4f24 100644
--- a/apps/checker/http_test.go
+++ b/apps/checker/http_test.go
@@ -1,15 +1,35 @@
package checker_test
import (
+ "bytes"
"context"
+ "io"
"net/http"
"testing"
+ "github.com/stretchr/testify/assert"
+
"github.com/openstatushq/openstatus/apps/checker"
"github.com/openstatushq/openstatus/apps/checker/request"
)
+// RoundTripFunc .
+type RoundTripFunc func(req *http.Request) *http.Response
+
+// RoundTrip .
+func (f RoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+ return f(req), nil
+}
+
+// NewTestClient returns *http.Client with Transport replaced to avoid making real calls
+func NewTestClient(fn RoundTripFunc) *http.Client {
+ return &http.Client{
+ Transport: RoundTripFunc(fn),
+ }
+}
+
func Test_ping(t *testing.T) {
+
type args struct {
client *http.Client
inputData request.HttpCheckerRequest
@@ -20,18 +40,40 @@ func Test_ping(t *testing.T) {
want checker.Response
wantErr bool
}{
- {name: "200", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct {
+ {name: "200", args: args{client: NewTestClient(func(req *http.Request) *http.Response {
+ return &http.Response{
+ StatusCode: http.StatusOK,
+ Body: io.NopCloser(bytes.NewBufferString(`OK`)),
+ Header: make(http.Header),
+ }
+ }), inputData: request.HttpCheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct {
Key string `json:"key"`
Value string `json:"value"`
- }{{Key: "", Value: ""}}}}, want: checker.Response{Status: 200}, wantErr: false},
- {name: "200", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct {
+ }{{Key: "", Value: ""}}}}, want: checker.Response{Status: 200, Body: "OK"}, wantErr: false},
+
+ {name: "200 with headers", args: args{client: NewTestClient(func(req *http.Request) *http.Response {
+ assert.Equal(t, "Value", req.Header.Get("Test"))
+ return &http.Response{
+ StatusCode: http.StatusOK,
+ Body: io.NopCloser(bytes.NewBufferString(`OK`)),
+ Header: make(http.Header),
+ }
+ }), inputData: request.HttpCheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct {
Key string `json:"key"`
Value string `json:"value"`
- }{{Key: "Test", Value: ""}}}}, want: checker.Response{Status: 200}, wantErr: false},
- {name: "500", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://openstat.us/500", CronTimestamp: 1}}, want: checker.Response{Status: 500}, wantErr: false},
- {name: "500", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://somethingthatwillfail.ed", CronTimestamp: 1}}, want: checker.Response{Status: 0}, wantErr: true},
+ }{{Key: "Test", Value: "Value"}}}}, want: checker.Response{Status: 200, Body: "OK"}, wantErr: false},
+
+ {name: "500", args: args{client: NewTestClient(func(req *http.Request) *http.Response {
+ return &http.Response{
+ StatusCode: http.StatusInternalServerError,
+ Body: io.NopCloser(bytes.NewBufferString(`OK`)),
+ Header: make(http.Header),
+ }
+ }), inputData: request.HttpCheckerRequest{URL: "https://openstat.us/500", CronTimestamp: 1}},
+ want: checker.Response{Status: 500, Body: "OK"}, wantErr: false},
- // TODO: Add test cases.
+ {name: "Wrong url should return an error", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://somethingthatwillfail.ed", CronTimestamp: 1}},
+ want: checker.Response{Status: 0}, wantErr: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
@@ -41,9 +83,14 @@ func Test_ping(t *testing.T) {
t.Errorf("Ping() error = %v, wantErr %v", err, tt.wantErr)
return
}
+
if got.Status != tt.want.Status {
t.Errorf("Ping() = %v, want %v", got, tt.want)
}
+
+ if got.Body != tt.want.Body {
+ t.Errorf("Ping() = %v, want %v", got, tt.want)
+ }
})
}
}