🗃️ add id and status in TB (#1249)

* 🗃️ add id and status in TB

* 🗃️ add go mod

* 😂 fix

apps/checker/go.mod

···
 require (
 	github.com/cenkalti/backoff/v4 v4.3.0
 	github.com/gin-gonic/gin v1.9.1
+	github.com/google/uuid v1.6.0
 	github.com/rs/zerolog v1.32.0
 	github.com/stretchr/testify v1.10.0
 	go.opentelemetry.io/otel v1.34.0
···
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/go-playground/validator/v10 v10.19.0 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
-	github.com/google/uuid v1.6.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect

apps/checker/handlers/checker.go

···
 
 	"github.com/cenkalti/backoff/v4"
 	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
 	"github.com/rs/zerolog/log"
 
 	"github.com/openstatushq/openstatus/apps/checker"
···
 }
 
 type PingData struct {
+	ID            string `json:"id"`
 	WorkspaceID   string `json:"workspaceId"`
 	MonitorID     string `json:"monitorId"`
 	URL           string `json:"url"`
···
 	Assertions    string `json:"assertions"`
 	Body          string `json:"body,omitempty"`
 	Trigger       string `json:"trigger,omitempty"`
+	RequestStatus string `json:"requestStatus,omitempty"`
 	Latency       int64  `json:"latency"`
 	CronTimestamp int64  `json:"cronTimestamp"`
 	Timestamp     int64  `json:"timestamp"`
···
 		headersAsString, err := json.Marshal(res.Headers)
 		if err != nil {
 			return fmt.Errorf("error while parsing headers %s: %w", req.URL, err)
+		}
+
+		id, err := uuid.NewV7()
+		if err != nil {
+			return fmt.Errorf("error while generating uuid %w", err)
+		}
+
+		var requestStatus = ""
+		switch req.Status {
+		case "active":
+			requestStatus = "success"
+			break
+		case "error":
+			requestStatus = "error"
+			break
+		case "degraded":
+			requestStatus = "degraded"
+			break
 		}
 
 		data := PingData{
+			ID:            id.String(),
 			Latency:       res.Latency,
 			StatusCode:    res.Status,
 			MonitorID:     req.MonitorID,
···
 			Headers:       string(headersAsString),
 			Body:          string(res.Body),
 			Trigger:       trigger,
+			RequestStatus: requestStatus,
 		}
 
 		statusCode := statusCode(res.Status)
···
 				CronTimestamp: req.CronTimestamp,
 				Latency:       res.Latency,
 			})
+			data.RequestStatus = "error"
 		}
 		// it's degraded
 		if isSuccessfull && req.DegradedAfter > 0 && res.Latency > req.DegradedAfter && req.Status != "degraded" {
···
 				CronTimestamp: req.CronTimestamp,
 				Latency:       res.Latency,
 			})
+			data.RequestStatus = "degraded"
 		}
 		// it's active
 		if isSuccessfull && req.DegradedAfter == 0 && req.Status != "active" {
···
 				CronTimestamp: req.CronTimestamp,
 				Latency:       res.Latency,
 			})
+			data.RequestStatus = "success"
 		}
 		// it's active
 		if isSuccessfull && res.Latency < req.DegradedAfter && req.DegradedAfter != 0 && req.Status != "active" {
···
 				StatusCode:    res.Status,
 				CronTimestamp: req.CronTimestamp,
 			})
+			data.RequestStatus = "success"
 		}
 
 		if err := h.TbClient.SendEvent(ctx, data, dataSourceName); err != nil {
···
 	}
 
 	if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil {
-		if err := h.TbClient.SendEvent(ctx, PingData{
+		id, e := uuid.NewV7()
+		if e != nil {
+			log.Ctx(ctx).Error().Err(e).Msg("failed to send event to tinybird")
+			return
+		}
+
+		data := PingData{
+			ID:            id.String(),
 			URL:           req.URL,
 			Region:        h.Region,
 			Message:       err.Error(),
···
 			Assertions:    assertionAsString,
 			Body:          "",
 			Trigger:       trigger,
-		}, dataSourceName); err != nil {
+			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")
 		}
 

apps/checker/handlers/tcp.go

···
 
 	"github.com/cenkalti/backoff/v4"
 	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
 	"github.com/openstatushq/openstatus/apps/checker"
 	otelOS "github.com/openstatushq/openstatus/apps/checker/pkg/otel"
 	"github.com/openstatushq/openstatus/apps/checker/request"
···
 
 // Only used for Tinybird.
 type TCPData struct {
-	Timing       string `json:"timing"`
-	ErrorMessage string `json:"errorMessage"`
-	Region       string `json:"region"`
-	Trigger      string `json:"trigger"`
-	URI          string `json:"uri"`
+	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"`
···
 
 		latency := res.TCPDone - res.TCPStart
 
+		var requestStatus = ""
+		switch req.Status {
+		case "active":
+			requestStatus = "success"
+			break
+		case "error":
+			requestStatus = "error"
+			break
+		case "degraded":
+			requestStatus = "degraded"
+			break
+		}
+
+
+		id, err := uuid.NewV7()
+		if err != nil {
+			return fmt.Errorf("error while generating uuid %w", err)
+		}
+
 		data := TCPData{
+			ID: id.String(),
 			WorkspaceID:   workspaceId,
 			Timestamp:     res.TCPStart,
 			Error:         0,
···
 			CronTimestamp: req.CronTimestamp,
 			Trigger:       trigger,
 			URI:           req.URI,
+			RequestStatus: requestStatus,
 		}
 
 		response = checker.TCPResponse{
···
 			JobType: "tcp",
 		}
 
-		if req.DegradedAfter == 0 &&  req.Status != "active" {
+		if req.DegradedAfter == 0 && req.Status != "active" {
 			checker.UpdateStatus(ctx, checker.UpdateData{
 				MonitorId:     req.MonitorID,
 				Status:        "active",
···
 				CronTimestamp: req.CronTimestamp,
 				Latency:       latency,
 			})
+			data.RequestStatus = "success"
 		}
 
 		if (req.DegradedAfter > 0 && latency < req.DegradedAfter) && req.Status != "active" {
···
 				CronTimestamp: req.CronTimestamp,
 				Latency:       latency,
 			})
+			data.RequestStatus = "success"
+
 		}
 
-		if req.DegradedAfter > 0 && latency > req.DegradedAfter  && req.Status != "degraded" {
+		if req.DegradedAfter > 0 && latency > req.DegradedAfter && req.Status != "degraded" {
 			checker.UpdateStatus(ctx, checker.UpdateData{
 				MonitorId:     req.MonitorID,
 				Status:        "degraded",
···
 				CronTimestamp: req.CronTimestamp,
 				Latency:       latency,
 			})
+			data.RequestStatus = "degraded"
+
 		}
 
 		if err := h.TbClient.SendEvent(ctx, data, dataSourceName); err != nil {
···
 	}
 
 	if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil {
-		if err := h.TbClient.SendEvent(ctx, TCPData{
+
+		id, e := uuid.NewV7()
+		if e != nil {
+			log.Ctx(ctx).Error().Err(e).Msg("failed to send event to tinybird")
+			return
+		}
+		data := TCPData{
+			ID: id.String(),
 			WorkspaceID:   workspaceId,
 			CronTimestamp: req.CronTimestamp,
 			ErrorMessage:  err.Error(),
···
 			Error:         1,
 			Trigger:       trigger,
 			URI:           req.URI,
-		}, dataSourceName); err != nil {
+			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{