+4

apps/checker/.golangci.yml

··· 1 1 + linters: 2 2 + enable-all: true 3 3 + disable-all: false 4 4 + fast: true

+15 -287

apps/checker/cmd/main.go

··· 2 2 3 3 import ( 4 4 "context" 5 5 - "encoding/json" 6 5 "errors" 7 6 "fmt" 8 7 "net/http" ··· 12 11 "time" 13 12 14 13 "github.com/gin-gonic/gin" 15 15 - "github.com/openstatushq/openstatus/apps/checker" 16 16 - "github.com/openstatushq/openstatus/apps/checker/pkg/assertions" 14 14 + "github.com/openstatushq/openstatus/apps/checker/handlers" 15 15 + 17 16 "github.com/openstatushq/openstatus/apps/checker/pkg/logger" 18 17 "github.com/openstatushq/openstatus/apps/checker/pkg/tinybird" 19 19 - "github.com/openstatushq/openstatus/apps/checker/request" 20 18 "github.com/rs/zerolog/log" 21 21 - 22 22 - backoff "github.com/cenkalti/backoff/v4" 23 19 ) 24 20 25 25 - type statusCode int 26 26 - 27 27 - // We should export it 28 28 - type PingResponse struct { 29 29 - Body string `json:"body,omitempty"` 30 30 - Headers string `json:"headers,omitempty"` 31 31 - Region string `json:"region"` 32 32 - RequestId int64 `json:"requestId,omitempty"` 33 33 - WorkspaceId int64 `json:"workspaceId,omitempty"` 34 34 - Latency int64 `json:"latency"` 35 35 - Time int64 `json:"time"` 36 36 - Timing checker.Timing `json:"timing"` 37 37 - Status int `json:"status,omitempty"` 38 38 - } 39 39 - 40 40 - func (s statusCode) IsSuccessful() bool { 41 41 - return s >= 200 && s < 300 42 42 - } 43 43 - 44 21 func main() { 45 22 ctx, cancel := context.WithCancel(context.Background()) 46 23 defer cancel() ··· 71 48 72 49 tinybirdClient := tinybird.NewClient(httpClient, tinyBirdToken) 73 50 74 74 - router := gin.New() 75 75 - router.POST("/checker", func(c *gin.Context) { 76 76 - ctx := c.Request.Context() 77 77 - dataSourceName := "ping_response__v8" 78 78 - if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", cronSecret) { 79 79 - c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"}) 80 80 - return 81 81 - } 82 82 - 83 83 - if cloudProvider == "fly" { 84 84 - // if the request has been routed to a wrong region, we forward it to the correct one. 85 85 - region := c.GetHeader("fly-prefer-region") 86 86 - if region != "" && region != flyRegion { 87 87 - c.Header("fly-replay", fmt.Sprintf("region=%s", region)) 88 88 - c.String(http.StatusAccepted, "Forwarding request to %s", region) 89 89 - return 90 90 - } 91 91 - } 92 92 - 93 93 - var req request.CheckerRequest 94 94 - if err := c.ShouldBindJSON(&req); err != nil { 95 95 - log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request") 96 96 - c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 97 97 - return 98 98 - } 99 99 - // We need a new client for each request to avoid connection reuse. 100 100 - requestClient := &http.Client{ 101 101 - Timeout: time.Duration(req.Timeout) * time.Millisecond, 102 102 - } 103 103 - defer requestClient.CloseIdleConnections() 104 104 - 105 105 - // Might be a more efficient way to do it 106 106 - var i interface{} = req.RawAssertions 107 107 - jsonBytes, _ := json.Marshal(i) 108 108 - assertionAsString := string(jsonBytes) 109 109 - if assertionAsString == "null" { 110 110 - assertionAsString = "" 111 111 - } 112 112 - 113 113 - var called int 114 114 - op := func() error { 115 115 - called++ 116 116 - res, err := checker.Ping(ctx, requestClient, req) 117 117 - if err != nil { 118 118 - return fmt.Errorf("unable to ping: %w", err) 119 119 - } 120 120 - statusCode := statusCode(res.StatusCode) 121 121 - 122 122 - var isSuccessfull bool = true 123 123 - if len(req.RawAssertions) > 0 { 124 124 - for _, a := range req.RawAssertions { 125 125 - var assert request.Assertion 126 126 - err = json.Unmarshal(a, &assert) 127 127 - if err != nil { 128 128 - // handle error 129 129 - return fmt.Errorf("unable to unmarshal assertion: %w", err) 130 130 - } 131 131 - switch assert.AssertionType { 132 132 - case request.AssertionHeader: 133 133 - var target assertions.HeaderTarget 134 134 - if err := json.Unmarshal(a, &target); err != nil { 135 135 - return fmt.Errorf("unable to unmarshal IntTarget: %w", err) 136 136 - } 137 137 - isSuccessfull = isSuccessfull && target.HeaderEvaluate(res.Headers) 138 138 - 139 139 - case request.AssertionTextBody: 140 140 - var target assertions.StringTargetType 141 141 - if err := json.Unmarshal(a, &target); err != nil { 142 142 - return fmt.Errorf("unable to unmarshal IntTarget: %w", err) 143 143 - } 144 144 - isSuccessfull = isSuccessfull && target.StringEvaluate(res.Body) 145 145 - 146 146 - case request.AssertionStatus: 147 147 - var target assertions.StatusTarget 148 148 - if err := json.Unmarshal(a, &target); err != nil { 149 149 - return fmt.Errorf("unable to unmarshal IntTarget: %w", err) 150 150 - } 151 151 - isSuccessfull = isSuccessfull && target.StatusEvaluate(int64(res.StatusCode)) 152 152 - case request.AssertionJsonBody: 153 153 - fmt.Println("assertion type", assert.AssertionType) 154 154 - default: 155 155 - fmt.Println("⚠️ Not Handled assertion type", assert.AssertionType) 156 156 - } 157 157 - } 158 158 - } else { 159 159 - isSuccessfull = statusCode.IsSuccessful() 160 160 - } 161 161 - 162 162 - // let's retry at least once if the status code is not successful. 163 163 - if !isSuccessfull && called < 2 { 164 164 - return fmt.Errorf("unable to ping: %v with status %v", res, res.StatusCode) 165 165 - } 166 166 - 167 167 - // it's in error if not successful 168 168 - if isSuccessfull { 169 169 - res.Error = 0 170 170 - // Small trick to avoid sending the body at the moment to TB 171 171 - res.Body = "" 172 172 - } else { 173 173 - res.Error = 1 174 174 - } 175 175 - 176 176 - res.Assertions = assertionAsString 177 177 - // That part could be refactored 178 178 - if !isSuccessfull && req.Status == "active" { 179 179 - // Q: Why here we do not check if the status was previously active? 180 180 - checker.UpdateStatus(ctx, checker.UpdateData{ 181 181 - MonitorId: req.MonitorID, 182 182 - Status: "error", 183 183 - StatusCode: res.StatusCode, 184 184 - Region: flyRegion, 185 185 - Message: res.Message, 186 186 - CronTimestamp: req.CronTimestamp, 187 187 - }) 188 188 - } 189 189 - // Check if the status is degraded 190 190 - if isSuccessfull && req.Status == "active" { 191 191 - if req.DegradedAfter > 0 && res.Latency > req.DegradedAfter { 192 192 - checker.UpdateStatus(ctx, checker.UpdateData{ 193 193 - MonitorId: req.MonitorID, 194 194 - Status: "degraded", 195 195 - Region: flyRegion, 196 196 - StatusCode: res.StatusCode, 197 197 - CronTimestamp: req.CronTimestamp, 198 198 - }) 199 199 - } 200 200 - } 201 201 - // We were in error and now we are successful don't check for degraded 202 202 - if isSuccessfull && req.Status == "error" { 203 203 - // Q: Why here we check the data before updating the status in this scenario? 204 204 - checker.UpdateStatus(ctx, checker.UpdateData{ 205 205 - MonitorId: req.MonitorID, 206 206 - Status: "active", 207 207 - Region: flyRegion, 208 208 - StatusCode: res.StatusCode, 209 209 - CronTimestamp: req.CronTimestamp, 210 210 - }) 211 211 - } 212 212 - // if we were in degraded and now we are successful, we should update the status to active 213 213 - if isSuccessfull && req.Status == "degraded" { 214 214 - if req.DegradedAfter > 0 && res.Latency <= req.DegradedAfter { 215 215 - checker.UpdateStatus(ctx, checker.UpdateData{ 216 216 - MonitorId: req.MonitorID, 217 217 - Status: "active", 218 218 - Region: flyRegion, 219 219 - StatusCode: res.StatusCode, 220 220 - CronTimestamp: req.CronTimestamp, 221 221 - }) 222 222 - } 223 223 - } 224 224 - 225 225 - if err := tinybirdClient.SendEvent(ctx, res, dataSourceName); err != nil { 226 226 - log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 227 227 - } 228 228 - 229 229 - return nil 230 230 - } 231 231 - 232 232 - if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil { 233 233 - if err := tinybirdClient.SendEvent(ctx, checker.PingData{ 234 234 - URL: req.URL, 235 235 - Region: flyRegion, 236 236 - Message: err.Error(), 237 237 - CronTimestamp: req.CronTimestamp, 238 238 - Timestamp: req.CronTimestamp, 239 239 - MonitorID: req.MonitorID, 240 240 - WorkspaceID: req.WorkspaceID, 241 241 - Error: 1, 242 242 - Assertions: assertionAsString, 243 243 - Body: "", 244 244 - }, dataSourceName); err != nil { 245 245 - log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 246 246 - } 247 247 - 248 248 - if req.Status == "active" { 249 249 - checker.UpdateStatus(ctx, checker.UpdateData{ 250 250 - MonitorId: req.MonitorID, 251 251 - Status: "error", 252 252 - Message: err.Error(), 253 253 - Region: flyRegion, 254 254 - CronTimestamp: req.CronTimestamp, 255 255 - }) 256 256 - } 51 51 + h := &handlers.Handler{ 52 52 + Secret: cronSecret, 53 53 + CloudProvider: cloudProvider, 54 54 + Region: flyRegion, 55 55 + TbClient: tinybirdClient, 56 56 + } 257 57 258 258 - } 259 259 - 260 260 - c.JSON(http.StatusOK, gin.H{"message": "ok"}) 261 261 - }) 58 58 + router := gin.New() 59 59 + router.POST("/checker", h.HTTPCheckerHandler) 60 60 + router.POST("/checker/http", h.HTTPCheckerHandler) 61 61 + router.POST("/checker/tcp", h.TCPHandler) 62 62 + router.POST("/ping/:region", h.PingRegionHandler) 63 63 + router.POST("/tcp/:region", h.TCPHandlerRegion) 262 64 263 65 router.GET("/health", func(c *gin.Context) { 264 66 c.JSON(http.StatusOK, gin.H{"message": "pong", "fly_region": flyRegion}) 265 67 }) 266 68 267 267 - router.POST("/ping/:region", func(c *gin.Context) { 268 268 - dataSourceName := "check_response__v1" 269 269 - region := c.Param("region") 270 270 - if region == "" { 271 271 - c.String(http.StatusBadRequest, "region is required") 272 272 - return 273 273 - } 274 274 - fmt.Printf("Start of /ping/%s\n", region) 275 275 - 276 276 - if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", cronSecret) { 277 277 - c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"}) 278 278 - return 279 279 - } 280 280 - 281 281 - if cloudProvider == "fly" { 282 282 - 283 283 - if region != flyRegion { 284 284 - c.Header("fly-replay", fmt.Sprintf("region=%s", region)) 285 285 - c.String(http.StatusAccepted, "Forwarding request to %s", region) 286 286 - return 287 287 - } 288 288 - } 289 289 - // We need a new client for each request to avoid connection reuse. 290 290 - requestClient := &http.Client{ 291 291 - Timeout: 45 * time.Second, 292 292 - } 293 293 - defer requestClient.CloseIdleConnections() 294 294 - 295 295 - var req request.PingRequest 296 296 - if err := c.ShouldBindJSON(&req); err != nil { 297 297 - log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request") 298 298 - c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 299 299 - return 300 300 - } 301 301 - var res checker.Response 302 302 - op := func() error { 303 303 - r, err := checker.SinglePing(c.Request.Context(), requestClient, req) 304 304 - if err != nil { 305 305 - return fmt.Errorf("unable to ping: %w", err) 306 306 - } 307 307 - 308 308 - r.Region = flyRegion 309 309 - 310 310 - headersAsString, err := json.Marshal(r.Headers) 311 311 - if err != nil { 312 312 - return err 313 313 - } 314 314 - 315 315 - tbData := PingResponse{ 316 316 - RequestId: req.RequestId, 317 317 - WorkspaceId: req.WorkspaceId, 318 318 - Status: r.Status, 319 319 - Latency: r.Latency, 320 320 - Body: r.Body, 321 321 - Headers: string(headersAsString), 322 322 - Time: r.Time, 323 323 - Timing: r.Timing, 324 324 - Region: r.Region, 325 325 - } 326 326 - 327 327 - res = r 328 328 - if tbData.RequestId != 0 { 329 329 - if err := tinybirdClient.SendEvent(ctx, tbData, dataSourceName); err != nil { 330 330 - log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 331 331 - } 332 332 - } 333 333 - return nil 334 334 - } 335 335 - if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil { 336 336 - c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 337 337 - return 338 338 - } 339 339 - c.JSON(http.StatusOK, res) 340 340 - }) 341 341 - 342 69 httpServer := &http.Server{ 343 70 Addr: fmt.Sprintf("0.0.0.0:%s", env("PORT", "8080")), 344 71 Handler: router, ··· 354 81 <-ctx.Done() 355 82 if err := httpServer.Shutdown(ctx); err != nil { 356 83 log.Ctx(ctx).Error().Err(err).Msg("failed to shutdown http server") 84 84 + 357 85 return 358 86 } 359 87 }

+262

apps/checker/handlers/checker.go

··· 1 1 + package handlers 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "fmt" 6 6 + "net/http" 7 7 + "time" 8 8 + 9 9 + "github.com/cenkalti/backoff/v4" 10 10 + "github.com/gin-gonic/gin" 11 11 + "github.com/openstatushq/openstatus/apps/checker" 12 12 + "github.com/openstatushq/openstatus/apps/checker/pkg/assertions" 13 13 + "github.com/openstatushq/openstatus/apps/checker/request" 14 14 + "github.com/rs/zerolog/log" 15 15 + ) 16 16 + 17 17 + type statusCode int 18 18 + 19 19 + func (s statusCode) IsSuccessful() bool { 20 20 + return s >= 200 && s < 300 21 21 + } 22 22 + 23 23 + type PingData struct { 24 24 + WorkspaceID string `json:"workspaceId"` 25 25 + MonitorID string `json:"monitorId"` 26 26 + URL string `json:"url"` 27 27 + Region string `json:"region"` 28 28 + Message string `json:"message,omitempty"` 29 29 + Timing string `json:"timing,omitempty"` 30 30 + Headers string `json:"headers,omitempty"` 31 31 + Assertions string `json:"assertions"` 32 32 + Body string `json:"body,omitempty"` 33 33 + Latency int64 `json:"latency"` 34 34 + CronTimestamp int64 `json:"cronTimestamp"` 35 35 + Timestamp int64 `json:"timestamp"` 36 36 + StatusCode int `json:"statusCode,omitempty"` 37 37 + Error uint8 `json:"error"` 38 38 + } 39 39 + 40 40 + func (h Handler) HTTPCheckerHandler(c *gin.Context) { 41 41 + ctx := c.Request.Context() 42 42 + dataSourceName := "ping_response__v8" 43 43 + 44 44 + if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", h.Secret) { 45 45 + c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"}) 46 46 + 47 47 + return 48 48 + } 49 49 + 50 50 + if h.CloudProvider == "fly" { 51 51 + // if the request has been routed to a wrong region, we forward it to the correct one. 52 52 + region := c.GetHeader("fly-prefer-region") 53 53 + if region != "" && region != h.Region { 54 54 + c.Header("fly-replay", fmt.Sprintf("region=%s", region)) 55 55 + c.String(http.StatusAccepted, "Forwarding request to %s", region) 56 56 + 57 57 + return 58 58 + } 59 59 + } 60 60 + 61 61 + var req request.HttpCheckerRequest 62 62 + if err := c.ShouldBindJSON(&req); err != nil { 63 63 + log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request") 64 64 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 65 65 + 66 66 + return 67 67 + } 68 68 + // We need a new client for each request to avoid connection reuse. 69 69 + requestClient := &http.Client{ 70 70 + Timeout: time.Duration(req.Timeout) * time.Millisecond, 71 71 + } 72 72 + defer requestClient.CloseIdleConnections() 73 73 + 74 74 + // Might be a more efficient way to do it 75 75 + var i interface{} = req.RawAssertions 76 76 + jsonBytes, _ := json.Marshal(i) 77 77 + assertionAsString := string(jsonBytes) 78 78 + 79 79 + if assertionAsString == "null" { 80 80 + assertionAsString = "" 81 81 + } 82 82 + 83 83 + var called int 84 84 + op := func() error { 85 85 + called++ 86 86 + res, err := checker.Http(ctx, requestClient, req) 87 87 + 88 88 + if err != nil { 89 89 + return fmt.Errorf("unable to ping: %w", err) 90 90 + } 91 91 + 92 92 + // In TB we need to store them as string 93 93 + timingAsString, err := json.Marshal(res.Timing) 94 94 + if err != nil { 95 95 + return fmt.Errorf("error while parsing timing data %s: %w", req.URL, err) 96 96 + } 97 97 + 98 98 + headersAsString, err := json.Marshal(res.Headers) 99 99 + if err != nil { 100 100 + return fmt.Errorf("error while parsing headers %s: %w", req.URL, err) 101 101 + } 102 102 + 103 103 + data := PingData{ 104 104 + Latency: res.Latency, 105 105 + StatusCode: res.Status, 106 106 + MonitorID: req.MonitorID, 107 107 + Region: h.Region, 108 108 + WorkspaceID: req.WorkspaceID, 109 109 + Timestamp: res.Timestamp, 110 110 + CronTimestamp: req.CronTimestamp, 111 111 + URL: req.URL, 112 112 + Timing: string(timingAsString), 113 113 + Headers: string(headersAsString), 114 114 + Body: string(res.Body), 115 115 + } 116 116 + 117 117 + statusCode := statusCode(res.Status) 118 118 + 119 119 + var isSuccessfull bool = true 120 120 + 121 121 + if len(req.RawAssertions) > 0 { 122 122 + for _, a := range req.RawAssertions { 123 123 + var assert request.Assertion 124 124 + err = json.Unmarshal(a, &assert) 125 125 + 126 126 + if err != nil { 127 127 + // handle error 128 128 + return fmt.Errorf("unable to unmarshal assertion: %w", err) 129 129 + } 130 130 + 131 131 + switch assert.AssertionType { 132 132 + case request.AssertionHeader: 133 133 + var target assertions.HeaderTarget 134 134 + if err := json.Unmarshal(a, &target); err != nil { 135 135 + return fmt.Errorf("unable to unmarshal IntTarget: %w", err) 136 136 + } 137 137 + isSuccessfull = isSuccessfull && target.HeaderEvaluate(data.Headers) 138 138 + 139 139 + case request.AssertionTextBody: 140 140 + var target assertions.StringTargetType 141 141 + if err := json.Unmarshal(a, &target); err != nil { 142 142 + return fmt.Errorf("unable to unmarshal IntTarget: %w", err) 143 143 + } 144 144 + isSuccessfull = isSuccessfull && target.StringEvaluate(data.Body) 145 145 + 146 146 + case request.AssertionStatus: 147 147 + var target assertions.StatusTarget 148 148 + if err := json.Unmarshal(a, &target); err != nil { 149 149 + return fmt.Errorf("unable to unmarshal IntTarget: %w", err) 150 150 + } 151 151 + isSuccessfull = isSuccessfull && target.StatusEvaluate(int64(res.Status)) 152 152 + case request.AssertionJsonBody: 153 153 + fmt.Println("assertion type", assert.AssertionType) 154 154 + default: 155 155 + fmt.Println("! Not Handled assertion type", assert.AssertionType) 156 156 + } 157 157 + } 158 158 + } else { 159 159 + isSuccessfull = statusCode.IsSuccessful() 160 160 + } 161 161 + 162 162 + // let's retry at least once if the status code is not successful. 163 163 + if !isSuccessfull && called < 2 { 164 164 + return fmt.Errorf("unable to ping: %v with status %v", res, res.Status) 165 165 + } 166 166 + 167 167 + // it's in error if not successful 168 168 + if isSuccessfull { 169 169 + data.Error = 0 170 170 + // Small trick to avoid sending the body at the moment to TB 171 171 + data.Body = "" 172 172 + } else { 173 173 + data.Error = 1 174 174 + } 175 175 + 176 176 + data.Assertions = assertionAsString 177 177 + // That part could be refactored 178 178 + if !isSuccessfull && req.Status == "active" { 179 179 + // Q: Why here we do not check if the status was previously active? 180 180 + checker.UpdateStatus(ctx, checker.UpdateData{ 181 181 + MonitorId: req.MonitorID, 182 182 + Status: "error", 183 183 + StatusCode: res.Status, 184 184 + Region: h.Region, 185 185 + Message: res.Error, 186 186 + CronTimestamp: req.CronTimestamp, 187 187 + }) 188 188 + } 189 189 + // Check if the status is degraded 190 190 + if isSuccessfull && req.Status == "active" { 191 191 + if req.DegradedAfter > 0 && res.Latency > req.DegradedAfter { 192 192 + checker.UpdateStatus(ctx, checker.UpdateData{ 193 193 + MonitorId: req.MonitorID, 194 194 + Status: "degraded", 195 195 + Region: h.Region, 196 196 + StatusCode: res.Status, 197 197 + CronTimestamp: req.CronTimestamp, 198 198 + }) 199 199 + } 200 200 + } 201 201 + // We were in error and now we are successful don't check for degraded 202 202 + if isSuccessfull && req.Status == "error" { 203 203 + // Q: Why here we check the data before updating the status in this scenario? 204 204 + checker.UpdateStatus(ctx, checker.UpdateData{ 205 205 + MonitorId: req.MonitorID, 206 206 + Status: "active", 207 207 + Region: h.Region, 208 208 + StatusCode: res.Status, 209 209 + CronTimestamp: req.CronTimestamp, 210 210 + }) 211 211 + } 212 212 + // if we were in degraded and now we are successful, we should update the status to active 213 213 + if isSuccessfull && req.Status == "degraded" { 214 214 + if req.DegradedAfter > 0 && res.Latency <= req.DegradedAfter { 215 215 + checker.UpdateStatus(ctx, checker.UpdateData{ 216 216 + MonitorId: req.MonitorID, 217 217 + Status: "active", 218 218 + Region: h.Region, 219 219 + StatusCode: res.Status, 220 220 + CronTimestamp: req.CronTimestamp, 221 221 + }) 222 222 + } 223 223 + } 224 224 + 225 225 + if err := h.TbClient.SendEvent(ctx, data, dataSourceName); err != nil { 226 226 + log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 227 227 + } 228 228 + 229 229 + return nil 230 230 + } 231 231 + 232 232 + if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil { 233 233 + if err := h.TbClient.SendEvent(ctx, PingData{ 234 234 + URL: req.URL, 235 235 + Region: h.Region, 236 236 + Message: err.Error(), 237 237 + CronTimestamp: req.CronTimestamp, 238 238 + Timestamp: req.CronTimestamp, 239 239 + MonitorID: req.MonitorID, 240 240 + WorkspaceID: req.WorkspaceID, 241 241 + Error: 1, 242 242 + Assertions: assertionAsString, 243 243 + Body: "", 244 244 + }, dataSourceName); err != nil { 245 245 + log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 246 246 + } 247 247 + 248 248 + if req.Status == "active" { 249 249 + checker.UpdateStatus(ctx, checker.UpdateData{ 250 250 + MonitorId: req.MonitorID, 251 251 + Status: "error", 252 252 + Message: err.Error(), 253 253 + Region: h.Region, 254 254 + CronTimestamp: req.CronTimestamp, 255 255 + }) 256 256 + } 257 257 + 258 258 + } 259 259 + 260 260 + c.JSON(http.StatusOK, gin.H{"message": "ok"}) 261 261 + 262 262 + }

+14

apps/checker/handlers/handler.go

··· 1 1 + package handlers 2 2 + 3 3 + import ( 4 4 + "github.com/openstatushq/openstatus/apps/checker/pkg/tinybird" 5 5 + ) 6 6 + 7 7 + type Handler struct { 8 8 + TbClient tinybird.Client 9 9 + Secret string 10 10 + CloudProvider string 11 11 + Region string 12 12 + } 13 13 + 14 14 + // Authorization could be handle by middleware

+148

apps/checker/handlers/ping.go

··· 1 1 + package handlers 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "fmt" 6 6 + "net/http" 7 7 + "time" 8 8 + 9 9 + "github.com/cenkalti/backoff/v4" 10 10 + "github.com/gin-gonic/gin" 11 11 + "github.com/openstatushq/openstatus/apps/checker" 12 12 + "github.com/openstatushq/openstatus/apps/checker/request" 13 13 + "github.com/rs/zerolog/log" 14 14 + ) 15 15 + 16 16 + type PingResponse struct { 17 17 + Body string `json:"body,omitempty"` 18 18 + Headers string `json:"headers,omitempty"` 19 19 + Region string `json:"region"` 20 20 + RequestId int64 `json:"requestId,omitempty"` 21 21 + WorkspaceId int64 `json:"workspaceId,omitempty"` 22 22 + Latency int64 `json:"latency"` 23 23 + Time int64 `json:"time"` 24 24 + Status int `json:"status,omitempty"` 25 25 + Timing checker.Timing `json:"timing"` 26 26 + } 27 27 + 28 28 + type Response struct { 29 29 + Headers map[string]string `json:"headers,omitempty"` 30 30 + Error string `json:"error,omitempty"` 31 31 + Body string `json:"body,omitempty"` 32 32 + Region string `json:"region"` 33 33 + Tags []string `json:"tags,omitempty"` 34 34 + RequestId int64 `json:"requestId,omitempty"` 35 35 + WorkspaceId int64 `json:"workspaceId,omitempty"` 36 36 + Latency int64 `json:"latency"` 37 37 + Time int64 `json:"time"` 38 38 + Timing checker.Timing `json:"timing"` 39 39 + Status int `json:"status,omitempty"` 40 40 + } 41 41 + 42 42 + func (h Handler) PingRegionHandler(c *gin.Context) { 43 43 + ctx := c.Request.Context() 44 44 + 45 45 + dataSourceName := "check_response__v1" 46 46 + region := c.Param("region") 47 47 + 48 48 + if region == "" { 49 49 + c.String(http.StatusBadRequest, "region is required") 50 50 + 51 51 + return 52 52 + } 53 53 + 54 54 + fmt.Printf("Start of /ping/%s\n", region) 55 55 + 56 56 + if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", h.Secret) { 57 57 + c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"}) 58 58 + 59 59 + return 60 60 + } 61 61 + 62 62 + if h.CloudProvider == "fly" { 63 63 + if region != h.Region { 64 64 + c.Header("fly-replay", fmt.Sprintf("region=%s", region)) 65 65 + c.String(http.StatusAccepted, "Forwarding request to %s", region) 66 66 + 67 67 + return 68 68 + } 69 69 + } 70 70 + 71 71 + // We need a new client for each request to avoid connection reuse. 72 72 + requestClient := &http.Client{ 73 73 + Timeout: 45 * time.Second, 74 74 + } 75 75 + defer requestClient.CloseIdleConnections() 76 76 + 77 77 + var req request.PingRequest 78 78 + if err := c.ShouldBindJSON(&req); err != nil { 79 79 + log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request") 80 80 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 81 81 + 82 82 + return 83 83 + } 84 84 + 85 85 + var res checker.Response 86 86 + 87 87 + op := func() error { 88 88 + 89 89 + headers := make([]struct { 90 90 + Key string `json:"key"` 91 91 + Value string `json:"value"` 92 92 + }, 0) 93 93 + 94 94 + for key, value := range req.Headers { 95 95 + headers = append(headers, struct { 96 96 + Key string `json:"key"` 97 97 + Value string `json:"value"` 98 98 + }{Key: key, Value: value}) 99 99 + } 100 100 + 101 101 + input := request.HttpCheckerRequest{ 102 102 + Headers: headers, 103 103 + URL: req.URL, 104 104 + Method: req.Method, 105 105 + Body: req.Body, 106 106 + } 107 107 + 108 108 + r, err := checker.Http(c.Request.Context(), requestClient, input) 109 109 + 110 110 + if err != nil { 111 111 + return fmt.Errorf("unable to ping: %w", err) 112 112 + } 113 113 + 114 114 + headersAsString, err := json.Marshal(r.Headers) 115 115 + if err != nil { 116 116 + return nil 117 117 + } 118 118 + 119 119 + tbData := PingResponse{ 120 120 + RequestId: req.RequestId, 121 121 + WorkspaceId: req.WorkspaceId, 122 122 + Status: r.Status, 123 123 + Latency: r.Latency, 124 124 + Body: r.Body, 125 125 + Headers: string(headersAsString), 126 126 + Time: r.Timestamp, 127 127 + Timing: r.Timing, 128 128 + Region: h.Region, 129 129 + } 130 130 + 131 131 + res = r 132 132 + 133 133 + if tbData.RequestId != 0 { 134 134 + if err := h.TbClient.SendEvent(ctx, tbData, dataSourceName); err != nil { 135 135 + log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 136 136 + } 137 137 + } 138 138 + 139 139 + return nil 140 140 + } 141 141 + if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil { 142 142 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 143 143 + 144 144 + return 145 145 + } 146 146 + 147 147 + c.JSON(http.StatusOK, res) 148 148 + }

+218

apps/checker/handlers/tcp.go

··· 1 1 + package handlers 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "net/http" 6 6 + "strconv" 7 7 + 8 8 + "github.com/cenkalti/backoff/v4" 9 9 + "github.com/gin-gonic/gin" 10 10 + "github.com/openstatushq/openstatus/apps/checker" 11 11 + "github.com/openstatushq/openstatus/apps/checker/request" 12 12 + "github.com/rs/zerolog/log" 13 13 + ) 14 14 + 15 15 + type TCPResponse struct { 16 16 + Error string `json:"error,omitempty"` 17 17 + Region string `json:"region"` 18 18 + RequestId int64 `json:"requestId,omitempty"` 19 19 + WorkspaceID int64 `json:"workspaceId"` 20 20 + MonitorID int64 `json:"monitorId"` 21 21 + Timestamp int64 `json:"timestamp"` 22 22 + Timing checker.TCPResponseTiming `json:"timing"` 23 23 + } 24 24 + 25 25 + func (h Handler) TCPHandler(c *gin.Context) { 26 26 + ctx := c.Request.Context() 27 27 + dataSourceName := "tcp_response__v0" 28 28 + if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", h.Secret) { 29 29 + c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"}) 30 30 + return 31 31 + } 32 32 + 33 33 + if h.CloudProvider == "fly" { 34 34 + // if the request has been routed to a wrong region, we forward it to the correct one. 35 35 + region := c.GetHeader("fly-prefer-region") 36 36 + if region != "" && region != h.Region { 37 37 + c.Header("fly-replay", fmt.Sprintf("region=%s", region)) 38 38 + c.String(http.StatusAccepted, "Forwarding request to %s", region) 39 39 + return 40 40 + } 41 41 + } 42 42 + var req request.TCPCheckerRequest 43 43 + if err := c.ShouldBindJSON(&req); err != nil { 44 44 + log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request") 45 45 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 46 46 + return 47 47 + } 48 48 + workspaceId, err := strconv.ParseInt(req.WorkspaceID, 10, 64) 49 49 + if err != nil { 50 50 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 51 51 + return 52 52 + } 53 53 + monitorId, err := strconv.ParseInt(req.MonitorID, 10, 64) 54 54 + if err != nil { 55 55 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 56 56 + return 57 57 + } 58 58 + 59 59 + var called int 60 60 + op := func() error { 61 61 + called++ 62 62 + res, err := checker.PingTcp(int(req.Timeout), req.URL) 63 63 + if err != nil { 64 64 + return fmt.Errorf("unable to check tcp %s", err) 65 65 + } 66 66 + 67 67 + r := TCPResponse{ 68 68 + WorkspaceID: workspaceId, 69 69 + Timestamp: req.CronTimestamp, 70 70 + Timing: checker.TCPResponseTiming{ 71 71 + TCPStart: res.TCPStart, 72 72 + TCPDone: res.TCPDone, 73 73 + }, 74 74 + Region: h.Region, 75 75 + MonitorID: monitorId, 76 76 + } 77 77 + latency := res.TCPDone - res.TCPStart 78 78 + if req.Status == "active" && req.DegradedAfter > 0 && latency > req.DegradedAfter { 79 79 + checker.UpdateStatus(ctx, checker.UpdateData{ 80 80 + MonitorId: req.MonitorID, 81 81 + Status: "degraded", 82 82 + Region: h.Region, 83 83 + CronTimestamp: req.CronTimestamp, 84 84 + }) 85 85 + } 86 86 + if req.Status == "degraded" && req.DegradedAfter > 0 && latency <= req.DegradedAfter { 87 87 + checker.UpdateStatus(ctx, checker.UpdateData{ 88 88 + MonitorId: req.MonitorID, 89 89 + Status: "active", 90 90 + Region: h.Region, 91 91 + CronTimestamp: req.CronTimestamp, 92 92 + }) 93 93 + } 94 94 + 95 95 + if req.Status == "error" { 96 96 + checker.UpdateStatus(ctx, checker.UpdateData{ 97 97 + MonitorId: req.MonitorID, 98 98 + Status: "active", 99 99 + Region: h.Region, 100 100 + CronTimestamp: req.CronTimestamp, 101 101 + }) 102 102 + } 103 103 + 104 104 + if err := h.TbClient.SendEvent(ctx, r, dataSourceName); err != nil { 105 105 + log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 106 106 + } 107 107 + 108 108 + return nil 109 109 + } 110 110 + 111 111 + if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil { 112 112 + if err := h.TbClient.SendEvent(ctx, TCPResponse{ 113 113 + WorkspaceID: workspaceId, 114 114 + Timestamp: req.CronTimestamp, 115 115 + Error: err.Error(), 116 116 + Region: h.Region, 117 117 + MonitorID: monitorId, 118 118 + }, dataSourceName); err != nil { 119 119 + log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 120 120 + } 121 121 + 122 122 + if req.Status == "active" { 123 123 + checker.UpdateStatus(ctx, checker.UpdateData{ 124 124 + MonitorId: req.MonitorID, 125 125 + Status: "error", 126 126 + Message: err.Error(), 127 127 + Region: h.Region, 128 128 + CronTimestamp: req.CronTimestamp, 129 129 + }) 130 130 + } 131 131 + } 132 132 + c.JSON(http.StatusOK, gin.H{"message": "ok"}) 133 133 + } 134 134 + 135 135 + func (h Handler) TCPHandlerRegion(c *gin.Context) { 136 136 + ctx := c.Request.Context() 137 137 + dataSourceName := "check_tcp_response__v1" 138 138 + 139 139 + region := c.Param("region") 140 140 + if region == "" { 141 141 + c.String(http.StatusBadRequest, "region is required") 142 142 + return 143 143 + } 144 144 + 145 145 + if c.GetHeader("Authorization") != fmt.Sprintf("Basic %s", h.Secret) { 146 146 + c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"}) 147 147 + return 148 148 + } 149 149 + 150 150 + if h.CloudProvider == "fly" { 151 151 + // if the request has been routed to a wrong region, we forward it to the correct one. 152 152 + region := c.GetHeader("fly-prefer-region") 153 153 + if region != "" && region != h.Region { 154 154 + c.Header("fly-replay", fmt.Sprintf("region=%s", region)) 155 155 + c.String(http.StatusAccepted, "Forwarding request to %s", region) 156 156 + return 157 157 + } 158 158 + } 159 159 + var req request.TCPCheckerRequest 160 160 + if err := c.ShouldBindJSON(&req); err != nil { 161 161 + log.Ctx(ctx).Error().Err(err).Msg("failed to decode checker request") 162 162 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 163 163 + return 164 164 + } 165 165 + 166 166 + workspaceId, err := strconv.ParseInt(req.WorkspaceID, 10, 64) 167 167 + if err != nil { 168 168 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 169 169 + return 170 170 + } 171 171 + monitorId, err := strconv.ParseInt(req.MonitorID, 10, 64) 172 172 + if err != nil { 173 173 + c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"}) 174 174 + return 175 175 + } 176 176 + 177 177 + var called int 178 178 + var response TCPResponse 179 179 + op := func() error { 180 180 + called++ 181 181 + res, err := checker.PingTcp(int(req.Timeout), req.URL) 182 182 + if err != nil { 183 183 + return fmt.Errorf("unable to check tcp %s", err) 184 184 + } 185 185 + 186 186 + response = TCPResponse{ 187 187 + WorkspaceID: workspaceId, 188 188 + Timestamp: req.CronTimestamp, 189 189 + Timing: checker.TCPResponseTiming{ 190 190 + TCPStart: res.TCPStart, 191 191 + TCPDone: res.TCPDone, 192 192 + }, 193 193 + Region: h.Region, 194 194 + MonitorID: monitorId, 195 195 + } 196 196 + 197 197 + if req.RequestId != 0 { 198 198 + if err := h.TbClient.SendEvent(ctx, response, dataSourceName); err != nil { 199 199 + log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 200 200 + } 201 201 + } 202 202 + 203 203 + return nil 204 204 + } 205 205 + 206 206 + if err := backoff.Retry(op, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3)); err != nil { 207 207 + if err := h.TbClient.SendEvent(ctx, TCPResponse{ 208 208 + WorkspaceID: workspaceId, 209 209 + Timestamp: req.CronTimestamp, 210 210 + Error: err.Error(), 211 211 + Region: h.Region, 212 212 + MonitorID: monitorId, 213 213 + }, dataSourceName); err != nil { 214 214 + log.Ctx(ctx).Error().Err(err).Msg("failed to send event to tinybird") 215 215 + } 216 216 + } 217 217 + c.JSON(http.StatusOK, response) 218 218 + }

+155

apps/checker/http.go

··· 1 1 + package checker 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "context" 6 6 + "crypto/tls" 7 7 + "encoding/base64" 8 8 + "errors" 9 9 + "fmt" 10 10 + "io" 11 11 + "net/http" 12 12 + "net/http/httptrace" 13 13 + "net/url" 14 14 + "strings" 15 15 + "time" 16 16 + 17 17 + "github.com/openstatushq/openstatus/apps/checker/request" 18 18 + "github.com/rs/zerolog/log" 19 19 + ) 20 20 + 21 21 + type Timing struct { 22 22 + DnsStart int64 `json:"dnsStart"` 23 23 + DnsDone int64 `json:"dnsDone"` 24 24 + ConnectStart int64 `json:"connectStart"` 25 25 + ConnectDone int64 `json:"connectDone"` 26 26 + TlsHandshakeStart int64 `json:"tlsHandshakeStart"` 27 27 + TlsHandshakeDone int64 `json:"tlsHandshakeDone"` 28 28 + FirstByteStart int64 `json:"firstByteStart"` 29 29 + FirstByteDone int64 `json:"firstByteDone"` 30 30 + TransferStart int64 `json:"transferStart"` 31 31 + TransferDone int64 `json:"transferDone"` 32 32 + } 33 33 + 34 34 + type Response struct { 35 35 + Headers map[string]string `json:"headers,omitempty"` 36 36 + Body string `json:"body,omitempty"` 37 37 + Error string `json:"error,omitempty"` 38 38 + Latency int64 `json:"latency"` 39 39 + Timestamp int64 `json:"timestamp"` 40 40 + Status int `json:"status,omitempty"` 41 41 + Timing Timing `json:"timing"` 42 42 + } 43 43 + 44 44 + // FIXME: This should only return the TCP Timing Data; 45 45 + func Http(ctx context.Context, client *http.Client, inputData request.HttpCheckerRequest) (Response, error) { 46 46 + logger := log.Ctx(ctx).With().Str("monitor", inputData.URL).Logger() 47 47 + 48 48 + b := []byte(inputData.Body) 49 49 + if inputData.Method == http.MethodPost { 50 50 + for _, header := range inputData.Headers { 51 51 + if header.Key == "Content-Type" && header.Value == "application/octet-stream" { 52 52 + // split the body by comma and convert it to bytes it's data url base64 53 53 + data := strings.Split(inputData.Body, ",") 54 54 + if len(data) == 2 { 55 55 + decoded, err := base64.StdEncoding.DecodeString(data[1]) 56 56 + if err != nil { 57 57 + return Response{}, fmt.Errorf("error while decoding base64: %w", err) 58 58 + } 59 59 + 60 60 + b = decoded 61 61 + 62 62 + } 63 63 + } 64 64 + } 65 65 + } 66 66 + 67 67 + req, err := http.NewRequestWithContext(ctx, inputData.Method, inputData.URL, bytes.NewReader(b)) 68 68 + if err != nil { 69 69 + logger.Error().Err(err).Msg("error while creating req") 70 70 + return Response{}, fmt.Errorf("unable to create req: %w", err) 71 71 + } 72 72 + req.Header.Set("User-Agent", "OpenStatus/1.0") 73 73 + for _, header := range inputData.Headers { 74 74 + if header.Key != "" { 75 75 + req.Header.Set(header.Key, header.Value) 76 76 + } 77 77 + } 78 78 + 79 79 + if inputData.Method != http.MethodGet { 80 80 + head := req.Header 81 81 + _, ok := head["Content-Type"] 82 82 + if !ok { 83 83 + // by default we set the content type to application/json if it's a POST request 84 84 + req.Header.Set("Content-Type", "application/json") 85 85 + } 86 86 + } 87 87 + 88 88 + timing := Timing{} 89 89 + 90 90 + trace := &httptrace.ClientTrace{ 91 91 + DNSStart: func(_ httptrace.DNSStartInfo) { timing.DnsStart = time.Now().UTC().UnixMilli() }, 92 92 + DNSDone: func(_ httptrace.DNSDoneInfo) { timing.DnsDone = time.Now().UTC().UnixMilli() }, 93 93 + ConnectStart: func(_, _ string) { timing.ConnectStart = time.Now().UTC().UnixMilli() }, 94 94 + ConnectDone: func(_, _ string, _ error) { timing.ConnectDone = time.Now().UTC().UnixMilli() }, 95 95 + TLSHandshakeStart: func() { timing.TlsHandshakeStart = time.Now().UTC().UnixMilli() }, 96 96 + TLSHandshakeDone: func(_ tls.ConnectionState, _ error) { timing.TlsHandshakeDone = time.Now().UTC().UnixMilli() }, 97 97 + GotConn: func(_ httptrace.GotConnInfo) { 98 98 + timing.FirstByteStart = time.Now().UTC().UnixMilli() 99 99 + }, 100 100 + GotFirstResponseByte: func() { 101 101 + timing.FirstByteDone = time.Now().UTC().UnixMilli() 102 102 + timing.TransferStart = time.Now().UTC().UnixMilli() 103 103 + }, 104 104 + } 105 105 + 106 106 + req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) 107 107 + 108 108 + start := time.Now() 109 109 + 110 110 + response, err := client.Do(req) 111 111 + timing.TransferDone = time.Now().UTC().UnixMilli() 112 112 + latency := time.Since(start).Milliseconds() 113 113 + if err != nil { 114 114 + 115 115 + var urlErr *url.Error 116 116 + if errors.As(err, &urlErr) && urlErr.Timeout() { 117 117 + return Response{ 118 118 + Latency: latency, 119 119 + Timing: timing, 120 120 + Timestamp: start.UTC().UnixMilli(), 121 121 + Error: fmt.Sprintf("Timeout after %d ms", latency), 122 122 + }, nil 123 123 + } 124 124 + 125 125 + logger.Error().Err(err).Msg("error while pinging") 126 126 + 127 127 + return Response{}, fmt.Errorf("error with monitorURL %s: %w", inputData.URL, err) 128 128 + } 129 129 + defer response.Body.Close() 130 130 + 131 131 + body, err := io.ReadAll(response.Body) 132 132 + if err != nil { 133 133 + return Response{ 134 134 + Latency: latency, 135 135 + Timing: timing, 136 136 + Timestamp: start.UTC().UnixMilli(), 137 137 + Error: fmt.Sprintf("Cannot read response body: %s", err.Error()), 138 138 + }, fmt.Errorf("error with monitorURL %s: %w", inputData.URL, err) 139 139 + } 140 140 + 141 141 + headers := make(map[string]string) 142 142 + for key := range response.Header { 143 143 + headers[key] = response.Header.Get(key) 144 144 + } 145 145 + 146 146 + return Response{ 147 147 + Timestamp: start.UTC().UnixMilli(), 148 148 + Status: response.StatusCode, 149 149 + Headers: headers, 150 150 + Timing: timing, 151 151 + Latency: latency, 152 152 + Body: string(body), 153 153 + }, nil 154 154 + 155 155 + }

+49

apps/checker/http_test.go

··· 1 1 + package checker_test 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "net/http" 6 6 + "testing" 7 7 + 8 8 + "github.com/openstatushq/openstatus/apps/checker" 9 9 + "github.com/openstatushq/openstatus/apps/checker/request" 10 10 + ) 11 11 + 12 12 + func Test_ping(t *testing.T) { 13 13 + type args struct { 14 14 + client *http.Client 15 15 + inputData request.HttpCheckerRequest 16 16 + } 17 17 + tests := []struct { 18 18 + name string 19 19 + args args 20 20 + want checker.Response 21 21 + wantErr bool 22 22 + }{ 23 23 + {name: "200", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct { 24 24 + Key string `json:"key"` 25 25 + Value string `json:"value"` 26 26 + }{{Key: "", Value: ""}}}}, want: checker.Response{Status: 200}, wantErr: false}, 27 27 + {name: "200", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct { 28 28 + Key string `json:"key"` 29 29 + Value string `json:"value"` 30 30 + }{{Key: "Test", Value: ""}}}}, want: checker.Response{Status: 200}, wantErr: false}, 31 31 + {name: "500", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://openstat.us/500", CronTimestamp: 1}}, want: checker.Response{Status: 500}, wantErr: false}, 32 32 + {name: "500", args: args{client: &http.Client{}, inputData: request.HttpCheckerRequest{URL: "https://somethingthatwillfail.ed", CronTimestamp: 1}}, want: checker.Response{Status: 0}, wantErr: true}, 33 33 + 34 34 + // TODO: Add test cases. 35 35 + } 36 36 + for _, tt := range tests { 37 37 + t.Run(tt.name, func(t *testing.T) { 38 38 + got, err := checker.Http(context.Background(), tt.args.client, tt.args.inputData) 39 39 + 40 40 + if (err != nil) != tt.wantErr { 41 41 + t.Errorf("Ping() error = %v, wantErr %v", err, tt.wantErr) 42 42 + return 43 43 + } 44 44 + if got.Status != tt.want.Status { 45 45 + t.Errorf("Ping() = %v, want %v", got, tt.want) 46 46 + } 47 47 + }) 48 48 + } 49 49 + }

-313

apps/checker/ping.go

··· 1 1 - package checker 2 2 - 3 3 - import ( 4 4 - "bytes" 5 5 - "context" 6 6 - "crypto/tls" 7 7 - "encoding/base64" 8 8 - "encoding/json" 9 9 - "errors" 10 10 - "fmt" 11 11 - "io" 12 12 - "net/http" 13 13 - "net/http/httptrace" 14 14 - "net/url" 15 15 - "os" 16 16 - "strings" 17 17 - "time" 18 18 - 19 19 - "github.com/openstatushq/openstatus/apps/checker/request" 20 20 - "github.com/rs/zerolog/log" 21 21 - ) 22 22 - 23 23 - type PingData struct { 24 24 - WorkspaceID string `json:"workspaceId"` 25 25 - MonitorID string `json:"monitorId"` 26 26 - URL string `json:"url"` 27 27 - Region string `json:"region"` 28 28 - Message string `json:"message,omitempty"` 29 29 - Timing string `json:"timing,omitempty"` 30 30 - Headers string `json:"headers,omitempty"` 31 31 - Assertions string `json:"assertions"` 32 32 - Body string `json:"body,omitempty"` 33 33 - Latency int64 `json:"latency"` 34 34 - CronTimestamp int64 `json:"cronTimestamp"` 35 35 - Timestamp int64 `json:"timestamp"` 36 36 - StatusCode int `json:"statusCode,omitempty"` 37 37 - Error uint8 `json:"error"` 38 38 - } 39 39 - 40 40 - type Timing struct { 41 41 - DnsStart int64 `json:"dnsStart"` 42 42 - DnsDone int64 `json:"dnsDone"` 43 43 - ConnectStart int64 `json:"connectStart"` 44 44 - ConnectDone int64 `json:"connectDone"` 45 45 - TlsHandshakeStart int64 `json:"tlsHandshakeStart"` 46 46 - TlsHandshakeDone int64 `json:"tlsHandshakeDone"` 47 47 - FirstByteStart int64 `json:"firstByteStart"` 48 48 - FirstByteDone int64 `json:"firstByteDone"` 49 49 - TransferStart int64 `json:"transferStart"` 50 50 - TransferDone int64 `json:"transferDone"` 51 51 - } 52 52 - 53 53 - type Response struct { 54 54 - Headers map[string]string `json:"headers,omitempty"` 55 55 - Error string `json:"error,omitempty"` 56 56 - Body string `json:"body,omitempty"` 57 57 - Region string `json:"region"` 58 58 - Tags []string `json:"tags,omitempty"` 59 59 - RequestId int64 `json:"requestId,omitempty"` 60 60 - WorkspaceId int64 `json:"workspaceId,omitempty"` 61 61 - Latency int64 `json:"latency"` 62 62 - Time int64 `json:"time"` 63 63 - Timing Timing `json:"timing"` 64 64 - Status int `json:"status,omitempty"` 65 65 - } 66 66 - 67 67 - func Ping(ctx context.Context, client *http.Client, inputData request.CheckerRequest) (PingData, error) { 68 68 - logger := log.Ctx(ctx).With().Str("monitor", inputData.URL).Logger() 69 69 - region := os.Getenv("FLY_REGION") 70 70 - 71 71 - b := []byte(inputData.Body) 72 72 - if inputData.Method == http.MethodPost { 73 73 - for _, header := range inputData.Headers { 74 74 - if header.Key == "Content-Type" && header.Value == "application/octet-stream" { 75 75 - 76 76 - // split the body by comma and convert it to bytes 77 77 - data := strings.Split(inputData.Body, ",") 78 78 - if len(data) == 2 { 79 79 - 80 80 - decoded, err := base64.StdEncoding.DecodeString(data[1]) 81 81 - if err != nil { 82 82 - return PingData{}, fmt.Errorf("error while decoding base64: %w", err) 83 83 - } 84 84 - 85 85 - b = decoded 86 86 - 87 87 - } 88 88 - } 89 89 - } 90 90 - } 91 91 - 92 92 - req, err := http.NewRequestWithContext(ctx, inputData.Method, inputData.URL, bytes.NewReader(b)) 93 93 - if err != nil { 94 94 - logger.Error().Err(err).Msg("error while creating req") 95 95 - return PingData{}, fmt.Errorf("unable to create req: %w", err) 96 96 - } 97 97 - req.Header.Set("User-Agent", "OpenStatus/1.0") 98 98 - for _, header := range inputData.Headers { 99 99 - if header.Key != "" { 100 100 - req.Header.Set(header.Key, header.Value) 101 101 - } 102 102 - } 103 103 - if inputData.Method != http.MethodGet { 104 104 - head := req.Header 105 105 - _, ok := head["Content-Type"] 106 106 - if !ok { 107 107 - // by default we set the content type to application/json if it's a POST request 108 108 - req.Header.Set("Content-Type", "application/json") 109 109 - } 110 110 - } 111 111 - 112 112 - timing := Timing{} 113 113 - 114 114 - trace := &httptrace.ClientTrace{ 115 115 - DNSStart: func(_ httptrace.DNSStartInfo) { timing.DnsStart = time.Now().UTC().UnixMilli() }, 116 116 - DNSDone: func(_ httptrace.DNSDoneInfo) { timing.DnsDone = time.Now().UTC().UnixMilli() }, 117 117 - ConnectStart: func(_, _ string) { timing.ConnectStart = time.Now().UTC().UnixMilli() }, 118 118 - ConnectDone: func(_, _ string, _ error) { timing.ConnectDone = time.Now().UTC().UnixMilli() }, 119 119 - TLSHandshakeStart: func() { timing.TlsHandshakeStart = time.Now().UTC().UnixMilli() }, 120 120 - TLSHandshakeDone: func(_ tls.ConnectionState, _ error) { timing.TlsHandshakeDone = time.Now().UTC().UnixMilli() }, 121 121 - GotConn: func(_ httptrace.GotConnInfo) { 122 122 - timing.FirstByteStart = time.Now().UTC().UnixMilli() 123 123 - }, 124 124 - GotFirstResponseByte: func() { 125 125 - timing.FirstByteDone = time.Now().UTC().UnixMilli() 126 126 - timing.TransferStart = time.Now().UTC().UnixMilli() 127 127 - }, 128 128 - } 129 129 - 130 130 - req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) 131 131 - 132 132 - start := time.Now() 133 133 - 134 134 - response, err := client.Do(req) 135 135 - timing.TransferDone = time.Now().UTC().UnixMilli() 136 136 - latency := time.Since(start).Milliseconds() 137 137 - if err != nil { 138 138 - timingAsString, err2 := json.Marshal(timing) 139 139 - if err2 != nil { 140 140 - logger.Error().Err(err2).Msg("error while parsing timing data") 141 141 - } 142 142 - var urlErr *url.Error 143 143 - if errors.As(err, &urlErr) && urlErr.Timeout() { 144 144 - return PingData{ 145 145 - Latency: latency, 146 146 - MonitorID: inputData.MonitorID, 147 147 - Region: region, 148 148 - WorkspaceID: inputData.WorkspaceID, 149 149 - Timestamp: start.UTC().UnixMilli(), 150 150 - CronTimestamp: inputData.CronTimestamp, 151 151 - URL: inputData.URL, 152 152 - Message: fmt.Sprintf("Timeout after %d ms", latency), 153 153 - Timing: string(timingAsString), 154 154 - }, nil 155 155 - } 156 156 - 157 157 - logger.Error().Err(err).Msg("error while pinging") 158 158 - return PingData{}, fmt.Errorf("error with monitorURL %s: %w", inputData.URL, err) 159 159 - } 160 160 - defer response.Body.Close() 161 161 - 162 162 - body, err := io.ReadAll(response.Body) 163 163 - if err != nil { 164 164 - return PingData{ 165 165 - Latency: latency, 166 166 - MonitorID: inputData.MonitorID, 167 167 - Region: region, 168 168 - WorkspaceID: inputData.WorkspaceID, 169 169 - Timestamp: start.UTC().UnixMilli(), 170 170 - CronTimestamp: inputData.CronTimestamp, 171 171 - URL: inputData.URL, 172 172 - Message: fmt.Sprintf("Cannot read response body: %s", err.Error()), 173 173 - }, fmt.Errorf("error with monitorURL %s: %w", inputData.URL, err) 174 174 - } 175 175 - 176 176 - headers := make(map[string]string) 177 177 - for key := range response.Header { 178 178 - headers[key] = response.Header.Get(key) 179 179 - } 180 180 - 181 181 - // In TB we need to store them as string 182 182 - timingAsString, err := json.Marshal(timing) 183 183 - if err != nil { 184 184 - return PingData{}, fmt.Errorf("error while parsing timing data %s: %w", inputData.URL, err) 185 185 - } 186 186 - 187 187 - headersAsString, err := json.Marshal(headers) 188 188 - if err != nil { 189 189 - return PingData{}, fmt.Errorf("error while parsing headers %s: %w", inputData.URL, err) 190 190 - } 191 191 - 192 192 - return PingData{ 193 193 - Latency: latency, 194 194 - StatusCode: response.StatusCode, 195 195 - MonitorID: inputData.MonitorID, 196 196 - Region: region, 197 197 - WorkspaceID: inputData.WorkspaceID, 198 198 - Timestamp: start.UTC().UnixMilli(), 199 199 - CronTimestamp: inputData.CronTimestamp, 200 200 - URL: inputData.URL, 201 201 - Timing: string(timingAsString), 202 202 - Headers: string(headersAsString), 203 203 - Body: string(body), 204 204 - }, nil 205 205 - } 206 206 - 207 207 - func SinglePing(ctx context.Context, client *http.Client, inputData request.PingRequest) (Response, error) { 208 208 - logger := log.Ctx(ctx).With().Str("monitor", inputData.URL).Logger() 209 209 - 210 210 - b := []byte(inputData.Body) 211 211 - if inputData.Headers["Content-Type"] == "application/octet-stream" { 212 212 - 213 213 - // split the body by comma and convert it to bytes 214 214 - data := strings.Split(inputData.Body, ",") 215 215 - if len(data) == 2 { 216 216 - 217 217 - decoded, err := base64.StdEncoding.DecodeString(data[1]) 218 218 - if err != nil { 219 219 - return Response{}, fmt.Errorf("error while decoding base64: %w", err) 220 220 - } 221 221 - 222 222 - b = decoded 223 223 - 224 224 - } 225 225 - } 226 226 - 227 227 - req, err := http.NewRequestWithContext(ctx, inputData.Method, inputData.URL, bytes.NewReader(b)) 228 228 - if err != nil { 229 229 - logger.Error().Err(err).Msg("error while creating req") 230 230 - return Response{}, fmt.Errorf("unable to create req: %w", err) 231 231 - } 232 232 - 233 233 - req.Header.Set("User-Agent", "OpenStatus/1.0") 234 234 - for key, value := range inputData.Headers { 235 235 - req.Header.Set(key, value) 236 236 - } 237 237 - 238 238 - if inputData.Method != http.MethodGet { 239 239 - head := req.Header 240 240 - _, ok := head["Content-Type"] 241 241 - if !ok { 242 242 - // by default we set the content type to application/json if it's a POST request 243 243 - req.Header.Set("Content-Type", "application/json") 244 244 - } 245 245 - // if the content type is octet-stream, we need to set the body as bytes 246 246 - 247 247 - } 248 248 - 249 249 - timing := Timing{} 250 250 - 251 251 - trace := &httptrace.ClientTrace{ 252 252 - DNSStart: func(_ httptrace.DNSStartInfo) { timing.DnsStart = time.Now().UTC().UnixMilli() }, 253 253 - DNSDone: func(_ httptrace.DNSDoneInfo) { timing.DnsDone = time.Now().UTC().UnixMilli() }, 254 254 - ConnectStart: func(_, _ string) { timing.ConnectStart = time.Now().UTC().UnixMilli() }, 255 255 - ConnectDone: func(_, _ string, _ error) { timing.ConnectDone = time.Now().UTC().UnixMilli() }, 256 256 - TLSHandshakeStart: func() { timing.TlsHandshakeStart = time.Now().UTC().UnixMilli() }, 257 257 - TLSHandshakeDone: func(_ tls.ConnectionState, _ error) { timing.TlsHandshakeDone = time.Now().UTC().UnixMilli() }, 258 258 - GotConn: func(_ httptrace.GotConnInfo) { 259 259 - timing.FirstByteStart = time.Now().UTC().UnixMilli() 260 260 - }, 261 261 - GotFirstResponseByte: func() { 262 262 - timing.FirstByteDone = time.Now().UTC().UnixMilli() 263 263 - timing.TransferStart = time.Now().UTC().UnixMilli() 264 264 - }, 265 265 - } 266 266 - 267 267 - req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) 268 268 - 269 269 - start := time.Now() 270 270 - res, err := client.Do(req) 271 271 - timing.TransferDone = time.Now().UTC().UnixMilli() 272 272 - latency := time.Since(start).Milliseconds() 273 273 - 274 274 - if err != nil { 275 275 - var urlErr *url.Error 276 276 - if errors.As(err, &urlErr) && urlErr.Timeout() { 277 277 - return Response{ 278 278 - Latency: latency, 279 279 - Timing: timing, 280 280 - Time: start.UTC().UnixMilli(), 281 281 - Error: fmt.Sprintf("Timeout after %d ms", latency), 282 282 - }, nil 283 283 - } 284 284 - 285 285 - logger.Error().Err(err).Msg("error while pinging") 286 286 - return Response{}, fmt.Errorf("error with monitorURL %s: %w", inputData.URL, err) 287 287 - } 288 288 - defer res.Body.Close() 289 289 - body, err := io.ReadAll(res.Body) 290 290 - 291 291 - if err != nil { 292 292 - return Response{ 293 293 - Latency: latency, 294 294 - Timing: timing, 295 295 - Time: start.UTC().UnixMilli(), 296 296 - Error: fmt.Sprintf("Cannot read response body: %s", err.Error()), 297 297 - }, fmt.Errorf("error with monitorURL %s: %w", inputData.URL, err) 298 298 - } 299 299 - 300 300 - headers := make(map[string]string) 301 301 - for key := range res.Header { 302 302 - headers[key] = res.Header.Get(key) 303 303 - } 304 304 - 305 305 - return Response{ 306 306 - Time: start.UTC().UnixMilli(), 307 307 - Status: res.StatusCode, 308 308 - Headers: headers, 309 309 - Timing: timing, 310 310 - Latency: latency, 311 311 - Body: string(body), 312 312 - }, nil 313 313 - }

-48

apps/checker/ping_test.go

··· 1 1 - package checker 2 2 - 3 3 - import ( 4 4 - "context" 5 5 - "net/http" 6 6 - "testing" 7 7 - 8 8 - "github.com/openstatushq/openstatus/apps/checker/request" 9 9 - ) 10 10 - 11 11 - func Test_ping(t *testing.T) { 12 12 - type args struct { 13 13 - client *http.Client 14 14 - inputData request.CheckerRequest 15 15 - } 16 16 - tests := []struct { 17 17 - name string 18 18 - args args 19 19 - want PingData 20 20 - wantErr bool 21 21 - }{ 22 22 - {name: "200", args: args{client: &http.Client{}, inputData: request.CheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct { 23 23 - Key string `json:"key"` 24 24 - Value string `json:"value"` 25 25 - }{{Key: "", Value: ""}}}}, want: PingData{URL: "https://openstat.us", StatusCode: 200}, wantErr: false}, 26 26 - {name: "200", args: args{client: &http.Client{}, inputData: request.CheckerRequest{URL: "https://openstat.us", CronTimestamp: 1, Headers: []struct { 27 27 - Key string `json:"key"` 28 28 - Value string `json:"value"` 29 29 - }{{Key: "Test", Value: ""}}}}, want: PingData{URL: "https://openstat.us", StatusCode: 200}, wantErr: false}, 30 30 - {name: "500", args: args{client: &http.Client{}, inputData: request.CheckerRequest{URL: "https://openstat.us/500", CronTimestamp: 1}}, want: PingData{URL: "https://openstat.us/500", StatusCode: 500}, wantErr: false}, 31 31 - {name: "500", args: args{client: &http.Client{}, inputData: request.CheckerRequest{URL: "https://somethingthatwillfail.ed", CronTimestamp: 1}}, want: PingData{URL: "https://openstat.us/500", StatusCode: 0}, wantErr: true}, 32 32 - 33 33 - // TODO: Add test cases. 34 34 - } 35 35 - for _, tt := range tests { 36 36 - t.Run(tt.name, func(t *testing.T) { 37 37 - got, err := Ping(context.Background(), tt.args.client, tt.args.inputData) 38 38 - 39 39 - if (err != nil) != tt.wantErr { 40 40 - t.Errorf("Ping() error = %v, wantErr %v", err, tt.wantErr) 41 41 - return 42 42 - } 43 43 - if got.StatusCode != tt.want.StatusCode { 44 44 - t.Errorf("Ping() = %v, want %v", got, tt.want) 45 45 - } 46 46 - }) 47 47 - } 48 48 - }

+21 -1

apps/checker/request/request.go

··· 45 45 RawTarget json.RawMessage `json:"target"` 46 46 } 47 47 48 48 - type CheckerRequest struct { 48 48 + type HttpCheckerRequest struct { 49 49 Headers []struct { 50 50 Key string `json:"key"` 51 51 Value string `json:"value"` ··· 60 60 CronTimestamp int64 `json:"cronTimestamp"` 61 61 Timeout int64 `json:"timeout"` 62 62 DegradedAfter int64 `json:"degradedAfter,omitempty"` 63 63 + } 64 64 + 65 65 + type TCPCheckerRequest struct { 66 66 + Status string `json:"status"` 67 67 + WorkspaceID string `json:"workspaceId"` 68 68 + URL string `json:"url"` 69 69 + MonitorID string `json:"monitorId"` 70 70 + RawAssertions []json.RawMessage `json:"assertions,omitempty"` 71 71 + RequestId int64 `json:"requestId,omitempty"` 72 72 + CronTimestamp int64 `json:"cronTimestamp"` 73 73 + Timeout int64 `json:"timeout"` 74 74 + DegradedAfter int64 `json:"degradedAfter,omitempty"` 75 75 + } 76 76 + 77 77 + type TCPRequest struct { 78 78 + WorkspaceID string `json:"workspaceId"` 79 79 + URL string `json:"url"` 80 80 + MonitorID string `json:"monitorId"` 81 81 + CronTimestamp int64 `json:"cronTimestamp"` 82 82 + Timeout int64 `json:"timeout"` 63 83 } 64 84 65 85 type PingRequest struct {

+38

apps/checker/tcp.go

··· 1 1 + package checker 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "net" 6 6 + "strings" 7 7 + "time" 8 8 + ) 9 9 + 10 10 + type TCPData struct { 11 11 + WorkspaceID string `json:"workspaceId"` 12 12 + MonitorID string `json:"monitorId"` 13 13 + Timestamp int64 `json:"timestamp"` 14 14 + } 15 15 + 16 16 + type TCPResponseTiming struct { 17 17 + TCPStart int64 `json:"tcpStart"` 18 18 + TCPDone int64 `json:"tcpDone"` 19 19 + } 20 20 + 21 21 + func PingTcp(timeout int, url string) (TCPResponseTiming, error) { 22 22 + start := time.Now().UTC().UnixMilli() 23 23 + conn, err := net.DialTimeout("tcp", url, time.Duration(timeout)*time.Second) 24 24 + 25 25 + if err != nil { 26 26 + if e := err.(*net.OpError).Timeout(); e { 27 27 + return TCPResponseTiming{}, fmt.Errorf("timeout after %d ms", timeout*1000) 28 28 + } 29 29 + if strings.Contains(err.Error(), "connection refused") { 30 30 + return TCPResponseTiming{}, fmt.Errorf("connection refused") 31 31 + } 32 32 + return TCPResponseTiming{}, fmt.Errorf("dial error: %v", err) 33 33 + } 34 34 + stop := time.Now().UTC().UnixMilli() 35 35 + defer conn.Close() 36 36 + 37 37 + return TCPResponseTiming{TCPStart: start, TCPDone: stop}, nil 38 38 + }

+41

apps/checker/tcp_test.go

··· 1 1 + package checker_test 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + 6 6 + "github.com/openstatushq/openstatus/apps/checker" 7 7 + ) 8 8 + 9 9 + func TestPingTcp(t *testing.T) { 10 10 + type args struct { 11 11 + url string 12 12 + timeout int 13 13 + } 14 14 + tests := []struct { 15 15 + name string 16 16 + args args 17 17 + want checker.TCPResponseTiming 18 18 + wantErr bool 19 19 + }{ 20 20 + {name: "will failed", args: args{url: "error", timeout: 60}, wantErr: true}, 21 21 + {name: "will be ok", args: args{url: "openstat.us:443", timeout: 60}, wantErr: false}, 22 22 + } 23 23 + for _, tt := range tests { 24 24 + t.Run(tt.name, func(t *testing.T) { 25 25 + got, err := checker.PingTcp(tt.args.timeout, tt.args.url) 26 26 + if (err != nil) != tt.wantErr { 27 27 + t.Errorf("PingTcp() error = %v, wantErr %v", err, tt.wantErr) 28 28 + return 29 29 + } 30 30 + if got.TCPStart == 0 && tt.wantErr == false { 31 31 + t.Errorf("PingTcp() = %v", got) 32 32 + return 33 33 + } 34 34 + if got.TCPDone == 0 && tt.wantErr == false { 35 35 + t.Errorf("PingTcp() = %v", got) 36 36 + return 37 37 + } 38 38 + 39 39 + }) 40 40 + } 41 41 + }

+14 -1

apps/web/src/app/api/checker/cron/_cron.ts

··· 168 168 Authorization: `Basic ${env.CRON_SECRET}`, 169 169 }, 170 170 httpMethod: "POST", 171 171 - url: `https://openstatus-checker.fly.dev/checker?monitor_id=${row.id}`, 171 171 + url: generateUrl({ row }), 172 172 body: Buffer.from(JSON.stringify(payload)).toString("base64"), 173 173 }, 174 174 scheduleTime: { ··· 179 179 const request = { parent: parent, task: newTask }; 180 180 return client.createTask(request); 181 181 }; 182 182 + 183 183 + function generateUrl({ row }: { row: z.infer<typeof selectMonitorSchema> }) { 184 184 + switch (row.jobType) { 185 185 + case "http": 186 186 + // FIXME: remove this after the migration 187 187 + case "other": 188 188 + return `https://openstatus-checker.fly.dev/checker/http?monitor_id=${row.id}`; 189 189 + case "tcp": 190 190 + return `https://openstatus-checker.fly.dev/checker/tcp?monitor_id=${row.id}`; 191 191 + default: 192 192 + throw new Error("Invalid jobType"); 193 193 + } 194 194 + }

+44

apps/web/src/app/api/checker/test/http/route.ts

··· 1 1 + import { NextResponse } from "next/server"; 2 2 + import { z } from "zod"; 3 3 + 4 4 + import { monitorFlyRegionSchema } from "@openstatus/db/src/schema/constants"; 5 5 + 6 6 + import { checkRegion } from "@/components/ping-response-analysis/utils"; 7 7 + import { payloadSchema } from "../../schema"; 8 8 + import { isAnInvalidTestUrl } from "../../utils"; 9 9 + 10 10 + export const runtime = "edge"; 11 11 + export const preferredRegion = "auto"; 12 12 + export const dynamic = "force-dynamic"; 13 13 + export const revalidate = 0; 14 14 + 15 15 + export function GET() { 16 16 + return NextResponse.json({ success: true }); 17 17 + } 18 18 + 19 19 + export async function POST(request: Request) { 20 20 + try { 21 21 + const json = await request.json(); 22 22 + const _valid = payloadSchema 23 23 + .pick({ url: true, method: true, headers: true, body: true }) 24 24 + .merge(z.object({ region: monitorFlyRegionSchema.default("ams") })) 25 25 + .safeParse(json); 26 26 + 27 27 + if (!_valid.success) { 28 28 + return NextResponse.json({ success: false }, { status: 400 }); 29 29 + } 30 30 + 31 31 + const { url, region, method, headers, body } = _valid.data; 32 32 + // 🧑‍💻 for the smart one who want to create a loop hole 33 33 + if (isAnInvalidTestUrl(url)) { 34 34 + return NextResponse.json({ success: true }, { status: 200 }); 35 35 + } 36 36 + 37 37 + const res = await checkRegion(url, region, { method, headers, body }); 38 38 + 39 39 + return NextResponse.json(res); 40 40 + } catch (e) { 41 41 + console.error(e); 42 42 + return NextResponse.json({ success: false }, { status: 400 }); 43 43 + } 44 44 + }

+69

apps/web/src/app/api/checker/test/tcp/route.ts

··· 1 1 + import { NextResponse } from "next/server"; 2 2 + import { z } from "zod"; 3 3 + 4 4 + import { 5 5 + type MonitorFlyRegion, 6 6 + monitorFlyRegionSchema, 7 7 + } from "@openstatus/db/src/schema/constants"; 8 8 + 9 9 + import { TCPResponse, tcpPayload } from "./schema"; 10 10 + 11 11 + export const runtime = "edge"; 12 12 + export const preferredRegion = "auto"; 13 13 + export const dynamic = "force-dynamic"; 14 14 + export const revalidate = 0; 15 15 + 16 16 + export function GET() { 17 17 + return NextResponse.json({ success: true }); 18 18 + } 19 19 + 20 20 + export async function POST(request: Request) { 21 21 + try { 22 22 + const json = await request.json(); 23 23 + const _valid = tcpPayload 24 24 + .merge(z.object({ region: monitorFlyRegionSchema.default("ams") })) 25 25 + .safeParse(json); 26 26 + 27 27 + if (!_valid.success) { 28 28 + return NextResponse.json({ success: false }, { status: 400 }); 29 29 + } 30 30 + 31 31 + const { url, region } = _valid.data; 32 32 + 33 33 + const res = await checkTCP(url, region); 34 34 + 35 35 + return NextResponse.json(res); 36 36 + } catch (e) { 37 37 + console.error(e); 38 38 + return NextResponse.json({ success: false }, { status: 400 }); 39 39 + } 40 40 + } 41 41 + async function checkTCP(url: string, region: MonitorFlyRegion) { 42 42 + // 43 43 + const res = await fetch(`https://checker.openstatus.dev/ping/tcp/${region}`, { 44 44 + headers: { 45 45 + Authorization: `Basic ${process.env.CRON_SECRET}`, 46 46 + "Content-Type": "application/json", 47 47 + "fly-prefer-region": region, 48 48 + }, 49 49 + method: "POST", 50 50 + body: JSON.stringify({ 51 51 + url, 52 52 + }), 53 53 + next: { revalidate: 0 }, 54 54 + }); 55 55 + 56 56 + const json = await res.json(); 57 57 + 58 58 + const data = TCPResponse.safeParse(json); 59 59 + 60 60 + if (!data.success) { 61 61 + console.log(json); 62 62 + console.error( 63 63 + `something went wrong with result ${json} request to ${url} error ${data.error.message}`, 64 64 + ); 65 65 + throw new Error(data.error.message); 66 66 + } 67 67 + 68 68 + return data.data; 69 69 + }

+27

apps/web/src/app/api/checker/test/tcp/schema.ts

··· 1 1 + import { z } from "zod"; 2 2 + 3 3 + import { monitorFlyRegionSchema } from "@openstatus/db/src/schema/constants"; 4 4 + 5 5 + export const tcpPayload = z.object({ 6 6 + workspaceId: z.string(), 7 7 + monitorId: z.string(), 8 8 + url: z.string(), 9 9 + cronTimestamp: z.number(), 10 10 + timeout: z.number().default(45000), 11 11 + degradedAfter: z.number().nullable(), 12 12 + }); 13 13 + 14 14 + export const TCPResponse = z.object({ 15 15 + requestId: z.string().optional(), 16 16 + workspaceId: z.string(), 17 17 + monitorId: z.string(), 18 18 + timestamp: z.number(), 19 19 + timing: z.object({ 20 20 + tcpStart: z.number(), 21 21 + tcpDone: z.number(), 22 22 + }), 23 23 + error: z.string().optional(), 24 24 + region: monitorFlyRegionSchema, 25 25 + }); 26 26 + 27 27 + export type tcpPayload = z.infer<typeof tcpPayload>;

+11 -1

apps/web/src/components/forms/monitor/form.tsx

··· 97 97 ) as any, // TS considers a.type === "textBody" 98 98 degradedAfter: defaultValues?.degradedAfter, 99 99 timeout: defaultValues?.timeout || 45000, 100 100 + jobType: defaultValues?.jobType || "http", 100 101 }, 101 102 }); 102 103 const router = useRouter(); 103 104 const pathname = usePathname(); 104 105 const [isPending, setPending] = React.useState(false); 105 106 const [pingFailed, setPingFailed] = React.useState(false); 107 107 + const type = React.useMemo( 108 108 + () => (defaultValues ? "update" : "create"), 109 109 + [defaultValues], 110 110 + ); 106 111 107 112 const handleDataUpdateOrInsertion = async (props: InsertMonitor) => { 108 113 if (defaultValues) { ··· 176 181 statusAssertions, 177 182 headerAssertions, 178 183 textBodyAssertions, 184 184 + jobType, 179 185 } = form.getValues(); 186 186 + 187 187 + // FIXME: add support for TCP 188 188 + if (jobType !== "http") 189 189 + return { error: "Only HTTP tests are supported. Coming soon..." }; 180 190 181 191 if ( 182 192 body && ··· 311 321 ) : null} 312 322 </TabsList> 313 323 <TabsContent value="request"> 314 314 - <SectionRequests {...{ form, pingEndpoint }} /> 324 324 + <SectionRequests {...{ form, pingEndpoint, type }} /> 315 325 </TabsContent> 316 326 <TabsContent value="assertions"> 317 327 <SectionAssertions {...{ form }} />

+1 -1

apps/web/src/components/forms/monitor/general.tsx

··· 83 83 /> 84 84 </FormControl> 85 85 <FormDescription> 86 86 - Easily categorize your monitors. 86 86 + Categorize your monitors. Create new tags by typing a name. 87 87 </FormDescription> 88 88 <FormMessage /> 89 89 </FormItem>

+217 -205

apps/web/src/components/forms/monitor/section-assertions.tsx

··· 25 25 SelectValue, 26 26 } from "@openstatus/ui"; 27 27 28 28 + import { EmptyState } from "@/components/dashboard/empty-state"; 28 29 import { Icons } from "@/components/icons"; 29 30 import { SectionHeader } from "../shared/section-header"; 30 31 ··· 38 39 interface Props { 39 40 form: UseFormReturn<InsertMonitor>; 40 41 } 42 42 + 43 43 + // REMINDER: once we have different types of assertions based on different jobTypes 44 44 + // we shoulds start creating a mapping function with allowed assertions for each jobType 41 45 42 46 export function SectionAssertions({ form }: Props) { 43 47 const statusAssertions = useFieldArray({ ··· 132 136 </> 133 137 } 134 138 /> 135 135 - <div className="flex flex-col gap-4"> 136 136 - {statusAssertions.fields.map((f, i) => ( 137 137 - <div key={f.id} className="grid grid-cols-12 items-center gap-4"> 138 138 - <p className="col-span-2 text-muted-foreground text-sm"> 139 139 - Status Code 140 140 - </p> 141 141 - <div className="col-span-3" /> 142 142 - <FormField 143 143 - control={form.control} 144 144 - name={`statusAssertions.${i}.compare`} 145 145 - render={({ field }) => ( 146 146 - <FormItem className="col-span-3 w-full"> 147 147 - <Select 148 148 - onValueChange={field.onChange} 149 149 - defaultValue={field.value} 150 150 - > 151 151 - <FormControl> 152 152 - <SelectTrigger> 153 153 - <SelectValue defaultValue="eq" placeholder="Equal" /> 154 154 - </SelectTrigger> 155 155 - </FormControl> 156 156 - <SelectContent> 157 157 - {Object.entries(numberCompareDictionary).map( 158 158 - ([key, value]) => ( 159 159 - <SelectItem key={key} value={key}> 160 160 - {value} 161 161 - </SelectItem> 162 162 - ), 163 163 - )} 164 164 - </SelectContent> 165 165 - </Select> 166 166 - </FormItem> 167 167 - )} 168 168 - /> 169 169 - <Input 170 170 - {...form.register(`statusAssertions.${i}.target`, { 171 171 - required: true, 172 172 - valueAsNumber: true, 173 173 - validate: (value) => 174 174 - value <= 599 || "Value must be 599 or lower", 175 175 - })} 176 176 - type="number" 177 177 - placeholder="200" 178 178 - className="col-span-3" 179 179 - /> 180 180 - <div className="col-span-1"> 181 181 - <Button 182 182 - size="icon" 183 183 - onClick={() => statusAssertions.remove(i)} 184 184 - variant="ghost" 185 185 - type="button" 186 186 - > 187 187 - <Icons.trash className="h-4 w-4" /> 188 188 - </Button> 139 139 + {form.getValues("jobType") === "http" ? ( 140 140 + <div className="flex flex-col gap-4"> 141 141 + {statusAssertions.fields.map((f, i) => ( 142 142 + <div key={f.id} className="grid grid-cols-12 items-center gap-4"> 143 143 + <p className="col-span-2 text-muted-foreground text-sm"> 144 144 + Status Code 145 145 + </p> 146 146 + <div className="col-span-3" /> 147 147 + <FormField 148 148 + control={form.control} 149 149 + name={`statusAssertions.${i}.compare`} 150 150 + render={({ field }) => ( 151 151 + <FormItem className="col-span-3 w-full"> 152 152 + <Select 153 153 + onValueChange={field.onChange} 154 154 + defaultValue={field.value} 155 155 + > 156 156 + <FormControl> 157 157 + <SelectTrigger> 158 158 + <SelectValue defaultValue="eq" placeholder="Equal" /> 159 159 + </SelectTrigger> 160 160 + </FormControl> 161 161 + <SelectContent> 162 162 + {Object.entries(numberCompareDictionary).map( 163 163 + ([key, value]) => ( 164 164 + <SelectItem key={key} value={key}> 165 165 + {value} 166 166 + </SelectItem> 167 167 + ), 168 168 + )} 169 169 + </SelectContent> 170 170 + </Select> 171 171 + </FormItem> 172 172 + )} 173 173 + /> 174 174 + <Input 175 175 + {...form.register(`statusAssertions.${i}.target`, { 176 176 + required: true, 177 177 + valueAsNumber: true, 178 178 + validate: (value) => 179 179 + value <= 599 || "Value must be 599 or lower", 180 180 + })} 181 181 + type="number" 182 182 + placeholder="200" 183 183 + className="col-span-3" 184 184 + /> 185 185 + <div className="col-span-1"> 186 186 + <Button 187 187 + size="icon" 188 188 + onClick={() => statusAssertions.remove(i)} 189 189 + variant="ghost" 190 190 + type="button" 191 191 + > 192 192 + <Icons.trash className="h-4 w-4" /> 193 193 + </Button> 194 194 + </div> 189 195 </div> 190 190 - </div> 191 191 - ))} 192 192 - {headerAssertions.fields.map((f, i) => ( 193 193 - <div key={f.id} className="grid grid-cols-12 items-center gap-4"> 194 194 - <p className="col-span-2 text-muted-foreground text-sm"> 195 195 - Response Header 196 196 - </p> 197 197 - <Input 198 198 - {...form.register(`headerAssertions.${i}.key`, { 199 199 - required: true, 200 200 - setValueAs: setEmptyOrStr, 201 201 - })} 202 202 - className="col-span-3" 203 203 - placeholder="X-Header" 204 204 - /> 205 205 - <FormField 206 206 - control={form.control} 207 207 - name={`headerAssertions.${i}.compare`} 208 208 - render={({ field }) => ( 209 209 - <FormItem className="col-span-3 w-full"> 210 210 - <Select 211 211 - onValueChange={field.onChange} 212 212 - defaultValue={field.value} 213 213 - > 214 214 - <FormControl> 215 215 - <SelectTrigger> 216 216 - <SelectValue defaultValue="eq" placeholder="Equal" /> 217 217 - </SelectTrigger> 218 218 - </FormControl> 219 219 - <SelectContent> 220 220 - {Object.entries(stringCompareDictionary).map( 221 221 - ([key, value]) => ( 222 222 - <SelectItem key={key} value={key}> 223 223 - {value} 224 224 - </SelectItem> 225 225 - ), 226 226 - )} 227 227 - </SelectContent> 228 228 - </Select> 229 229 - </FormItem> 230 230 - )} 231 231 - /> 232 232 - <Input 233 233 - {...form.register(`headerAssertions.${i}.target`)} 234 234 - className="col-span-3" 235 235 - placeholder="x-value" 236 236 - /> 237 237 - <div className="col-span-1"> 238 238 - <Button 239 239 - size="icon" 240 240 - onClick={() => headerAssertions.remove(i)} 241 241 - variant="ghost" 242 242 - > 243 243 - <Icons.trash className="h-4 w-4" /> 244 244 - </Button> 196 196 + ))} 197 197 + {headerAssertions.fields.map((f, i) => ( 198 198 + <div key={f.id} className="grid grid-cols-12 items-center gap-4"> 199 199 + <p className="col-span-2 text-muted-foreground text-sm"> 200 200 + Response Header 201 201 + </p> 202 202 + <Input 203 203 + {...form.register(`headerAssertions.${i}.key`, { 204 204 + required: true, 205 205 + setValueAs: setEmptyOrStr, 206 206 + })} 207 207 + className="col-span-3" 208 208 + placeholder="X-Header" 209 209 + /> 210 210 + <FormField 211 211 + control={form.control} 212 212 + name={`headerAssertions.${i}.compare`} 213 213 + render={({ field }) => ( 214 214 + <FormItem className="col-span-3 w-full"> 215 215 + <Select 216 216 + onValueChange={field.onChange} 217 217 + defaultValue={field.value} 218 218 + > 219 219 + <FormControl> 220 220 + <SelectTrigger> 221 221 + <SelectValue defaultValue="eq" placeholder="Equal" /> 222 222 + </SelectTrigger> 223 223 + </FormControl> 224 224 + <SelectContent> 225 225 + {Object.entries(stringCompareDictionary).map( 226 226 + ([key, value]) => ( 227 227 + <SelectItem key={key} value={key}> 228 228 + {value} 229 229 + </SelectItem> 230 230 + ), 231 231 + )} 232 232 + </SelectContent> 233 233 + </Select> 234 234 + </FormItem> 235 235 + )} 236 236 + /> 237 237 + <Input 238 238 + {...form.register(`headerAssertions.${i}.target`)} 239 239 + className="col-span-3" 240 240 + placeholder="x-value" 241 241 + /> 242 242 + <div className="col-span-1"> 243 243 + <Button 244 244 + size="icon" 245 245 + onClick={() => headerAssertions.remove(i)} 246 246 + variant="ghost" 247 247 + > 248 248 + <Icons.trash className="h-4 w-4" /> 249 249 + </Button> 250 250 + </div> 245 251 </div> 246 246 - </div> 247 247 - ))} 248 248 - {textBodyAssertions.fields.map((f, i) => ( 249 249 - <div key={f.id} className="grid grid-cols-12 items-center gap-4"> 250 250 - <p className="col-span-2 text-muted-foreground text-sm">Body</p> 251 251 - <div className="col-span-3" /> 252 252 - <FormField 253 253 - control={form.control} 254 254 - name={`textBodyAssertions.${i}.compare`} 255 255 - render={({ field }) => ( 256 256 - <FormItem className="col-span-3 w-full"> 257 257 - <Select 258 258 - onValueChange={field.onChange} 259 259 - defaultValue={field.value} 260 260 - > 261 261 - <FormControl> 262 262 - <SelectTrigger> 263 263 - <SelectValue defaultValue="eq" placeholder="Equal" /> 264 264 - </SelectTrigger> 265 265 - </FormControl> 266 266 - <SelectContent> 267 267 - {Object.entries(stringCompareDictionary).map( 268 268 - ([key, value]) => ( 269 269 - <SelectItem key={key} value={key}> 270 270 - {value} 271 271 - </SelectItem> 272 272 - ), 273 273 - )} 274 274 - </SelectContent> 275 275 - </Select> 276 276 - </FormItem> 277 277 - )} 278 278 - /> 279 279 - <Input 280 280 - {...form.register(`textBodyAssertions.${i}.target`, { 281 281 - required: true, 282 282 - })} 283 283 - placeholder="<html>...</html>" 284 284 - className="col-span-3" 285 285 - /> 286 286 - <div className="col-span-1"> 287 287 - <Button 288 288 - size="icon" 289 289 - onClick={() => textBodyAssertions.remove(i)} 290 290 - variant="ghost" 291 291 - type="button" 292 292 - > 293 293 - <Icons.trash className="h-4 w-4" /> 294 294 - </Button> 252 252 + ))} 253 253 + {textBodyAssertions.fields.map((f, i) => ( 254 254 + <div key={f.id} className="grid grid-cols-12 items-center gap-4"> 255 255 + <p className="col-span-2 text-muted-foreground text-sm">Body</p> 256 256 + <div className="col-span-3" /> 257 257 + <FormField 258 258 + control={form.control} 259 259 + name={`textBodyAssertions.${i}.compare`} 260 260 + render={({ field }) => ( 261 261 + <FormItem className="col-span-3 w-full"> 262 262 + <Select 263 263 + onValueChange={field.onChange} 264 264 + defaultValue={field.value} 265 265 + > 266 266 + <FormControl> 267 267 + <SelectTrigger> 268 268 + <SelectValue defaultValue="eq" placeholder="Equal" /> 269 269 + </SelectTrigger> 270 270 + </FormControl> 271 271 + <SelectContent> 272 272 + {Object.entries(stringCompareDictionary).map( 273 273 + ([key, value]) => ( 274 274 + <SelectItem key={key} value={key}> 275 275 + {value} 276 276 + </SelectItem> 277 277 + ), 278 278 + )} 279 279 + </SelectContent> 280 280 + </Select> 281 281 + </FormItem> 282 282 + )} 283 283 + /> 284 284 + <Input 285 285 + {...form.register(`textBodyAssertions.${i}.target`, { 286 286 + required: true, 287 287 + })} 288 288 + placeholder="<html>...</html>" 289 289 + className="col-span-3" 290 290 + /> 291 291 + <div className="col-span-1"> 292 292 + <Button 293 293 + size="icon" 294 294 + onClick={() => textBodyAssertions.remove(i)} 295 295 + variant="ghost" 296 296 + type="button" 297 297 + > 298 298 + <Icons.trash className="h-4 w-4" /> 299 299 + </Button> 300 300 + </div> 295 301 </div> 302 302 + ))} 303 303 + <div className="flex flex-wrap gap-4"> 304 304 + <Button 305 305 + variant="outline" 306 306 + type="button" 307 307 + onClick={() => 308 308 + statusAssertions.append({ 309 309 + version: "v1", 310 310 + type: "status", 311 311 + compare: "eq", 312 312 + target: 200, 313 313 + }) 314 314 + } 315 315 + > 316 316 + Add Status Code Assertion 317 317 + </Button> 318 318 + <Button 319 319 + variant="outline" 320 320 + type="button" 321 321 + onClick={() => 322 322 + headerAssertions.append({ 323 323 + version: "v1", 324 324 + type: "header", 325 325 + key: "Content-Type", 326 326 + compare: "eq", 327 327 + target: "application/json", 328 328 + }) 329 329 + } 330 330 + > 331 331 + Add Header Assertion 332 332 + </Button> 333 333 + 334 334 + <Button 335 335 + variant="outline" 336 336 + type="button" 337 337 + onClick={() => 338 338 + textBodyAssertions.append({ 339 339 + version: "v1", 340 340 + type: "textBody", 341 341 + compare: "eq", 342 342 + target: "", 343 343 + }) 344 344 + } 345 345 + > 346 346 + Add String Body Assertion 347 347 + </Button> 296 348 </div> 297 297 - ))} 298 298 - <div className="flex flex-wrap gap-4"> 299 299 - <Button 300 300 - variant="outline" 301 301 - type="button" 302 302 - onClick={() => 303 303 - statusAssertions.append({ 304 304 - version: "v1", 305 305 - type: "status", 306 306 - compare: "eq", 307 307 - target: 200, 308 308 - }) 309 309 - } 310 310 - > 311 311 - Add Status Code Assertion 312 312 - </Button> 313 313 - <Button 314 314 - variant="outline" 315 315 - type="button" 316 316 - onClick={() => 317 317 - headerAssertions.append({ 318 318 - version: "v1", 319 319 - type: "header", 320 320 - key: "Content-Type", 321 321 - compare: "eq", 322 322 - target: "application/json", 323 323 - }) 324 324 - } 325 325 - > 326 326 - Add Header Assertion 327 327 - </Button> 328 328 - 329 329 - <Button 330 330 - variant="outline" 331 331 - type="button" 332 332 - onClick={() => 333 333 - textBodyAssertions.append({ 334 334 - version: "v1", 335 335 - type: "textBody", 336 336 - compare: "eq", 337 337 - target: "", 338 338 - }) 339 339 - } 340 340 - > 341 341 - Add String Body Assertion 342 342 - </Button> 343 349 </div> 344 344 - </div> 350 350 + ) : ( 351 351 + <EmptyState 352 352 + icon="alert-triangle" 353 353 + title="No Assertions" 354 354 + description="Assertions are only available for HTTP monitors." 355 355 + /> 356 356 + )} 345 357 </div> 346 358 ); 347 359 }

+331

apps/web/src/components/forms/monitor/section-request-http.tsx

··· 1 1 + "use client"; 2 2 + 3 3 + import { Wand2, X } from "lucide-react"; 4 4 + import type * as React from "react"; 5 5 + import { useFieldArray } from "react-hook-form"; 6 6 + import type { UseFormReturn } from "react-hook-form"; 7 7 + 8 8 + import { 9 9 + monitorMethods, 10 10 + monitorMethodsSchema, 11 11 + } from "@openstatus/db/src/schema"; 12 12 + import type { InsertMonitor } from "@openstatus/db/src/schema"; 13 13 + import { 14 14 + Button, 15 15 + FormControl, 16 16 + FormDescription, 17 17 + FormField, 18 18 + FormItem, 19 19 + FormLabel, 20 20 + FormMessage, 21 21 + Input, 22 22 + Select, 23 23 + SelectContent, 24 24 + SelectItem, 25 25 + SelectTrigger, 26 26 + SelectValue, 27 27 + Textarea, 28 28 + Tooltip, 29 29 + TooltipContent, 30 30 + TooltipProvider, 31 31 + TooltipTrigger, 32 32 + } from "@openstatus/ui"; 33 33 + 34 34 + import { toast } from "@/lib/toast"; 35 35 + import { useRef, useState } from "react"; 36 36 + 37 37 + const contentTypes = [ 38 38 + { value: "application/octet-stream", label: "Binary File" }, 39 39 + { value: "application/json", label: "JSON" }, 40 40 + { value: "application/xml", label: "XML" }, 41 41 + { value: "application/yaml", label: "YAML" }, 42 42 + { value: "application/edn", label: "EDN" }, 43 43 + { value: "application/other", label: "Other" }, 44 44 + { value: "none", label: "None" }, 45 45 + ]; 46 46 + 47 47 + interface Props { 48 48 + form: UseFormReturn<InsertMonitor>; 49 49 + } 50 50 + 51 51 + // TODO: add Dialog with response informations when pingEndpoint! 52 52 + 53 53 + export function SectionRequestHTTP({ form }: Props) { 54 54 + const { fields, append, prepend, remove, update } = useFieldArray({ 55 55 + name: "headers", 56 56 + control: form.control, 57 57 + }); 58 58 + const inputRef = useRef<HTMLInputElement>(null); 59 59 + const watchMethod = form.watch("method"); 60 60 + const [file, setFile] = useState<string | undefined>(undefined); 61 61 + const [content, setContent] = useState<string | undefined>( 62 62 + fields.find((field) => field.key === "Content-Type")?.value, 63 63 + ); 64 64 + 65 65 + const validateJSON = (value?: string) => { 66 66 + if (!value) return; 67 67 + try { 68 68 + const obj = JSON.parse(value) as Record<string, unknown>; 69 69 + form.clearErrors("body"); 70 70 + return obj; 71 71 + } catch (_e) { 72 72 + form.setError("body", { 73 73 + message: "Not a valid JSON object", 74 74 + }); 75 75 + return false; 76 76 + } 77 77 + }; 78 78 + 79 79 + const uploadFile = async (event: React.ChangeEvent<HTMLInputElement>) => { 80 80 + if (event.target.files?.[0]) { 81 81 + const file = event.target.files[0]; 82 82 + 83 83 + // File too big, return error 84 84 + const fileSize = file.size / 1024 / 1024; // in MiB 85 85 + if (fileSize > 10) { 86 86 + // Display error message 87 87 + toast.error("File size is too big. Max 10MB allowed."); 88 88 + return; 89 89 + } 90 90 + 91 91 + const reader = new FileReader(); 92 92 + reader.onload = (event) => { 93 93 + if (event.target?.result && typeof event.target.result === "string") { 94 94 + form.setValue("body", event.target?.result); 95 95 + setFile(file.name); 96 96 + } 97 97 + }; 98 98 + 99 99 + reader.readAsDataURL(file); 100 100 + } 101 101 + }; 102 102 + 103 103 + const onPrettifyJSON = () => { 104 104 + const body = form.getValues("body"); 105 105 + const obj = validateJSON(body); 106 106 + if (obj) { 107 107 + const pretty = JSON.stringify(obj, undefined, 4); 108 108 + form.setValue("body", pretty); 109 109 + } 110 110 + }; 111 111 + 112 112 + return ( 113 113 + <div className="grid w-full gap-4"> 114 114 + <div className="grid gap-4 sm:grid-cols-7"> 115 115 + <FormField 116 116 + control={form.control} 117 117 + name="method" 118 118 + render={({ field }) => ( 119 119 + <FormItem className="sm:col-span-1"> 120 120 + <FormLabel>Method</FormLabel> 121 121 + <Select 122 122 + onValueChange={(value) => { 123 123 + field.onChange(monitorMethodsSchema.parse(value)); 124 124 + form.resetField("body", { defaultValue: "" }); 125 125 + setContent(undefined); 126 126 + }} 127 127 + defaultValue={field.value} 128 128 + > 129 129 + <FormControl> 130 130 + <SelectTrigger> 131 131 + <SelectValue placeholder="Select" /> 132 132 + </SelectTrigger> 133 133 + </FormControl> 134 134 + <SelectContent> 135 135 + {monitorMethods.map((method) => ( 136 136 + <SelectItem key={method} value={method}> 137 137 + {method} 138 138 + </SelectItem> 139 139 + ))} 140 140 + </SelectContent> 141 141 + </Select> 142 142 + <FormMessage /> 143 143 + </FormItem> 144 144 + )} 145 145 + /> 146 146 + <FormField 147 147 + control={form.control} 148 148 + name="url" 149 149 + render={({ field }) => ( 150 150 + <FormItem className="sm:col-span-6"> 151 151 + <FormLabel>URL</FormLabel> 152 152 + <FormControl> 153 153 + <Input 154 154 + className="bg-muted" 155 155 + placeholder="https://documenso.com/api/health" 156 156 + {...field} 157 157 + /> 158 158 + </FormControl> 159 159 + </FormItem> 160 160 + )} 161 161 + /> 162 162 + </div> 163 163 + <div className="space-y-2 sm:col-span-full"> 164 164 + <FormLabel>Request Header</FormLabel> 165 165 + {fields.map((field, index) => ( 166 166 + <div key={field.id} className="grid grid-cols-6 gap-4"> 167 167 + <FormField 168 168 + control={form.control} 169 169 + name={`headers.${index}.key`} 170 170 + render={({ field }) => ( 171 171 + <FormItem className="col-span-2"> 172 172 + <FormControl> 173 173 + <Input placeholder="key" {...field} /> 174 174 + </FormControl> 175 175 + </FormItem> 176 176 + )} 177 177 + /> 178 178 + <div className="col-span-4 flex items-center space-x-2"> 179 179 + <FormField 180 180 + control={form.control} 181 181 + name={`headers.${index}.value`} 182 182 + render={({ field }) => ( 183 183 + <FormItem className="w-full"> 184 184 + <FormControl> 185 185 + <Input placeholder="value" {...field} /> 186 186 + </FormControl> 187 187 + </FormItem> 188 188 + )} 189 189 + /> 190 190 + <Button 191 191 + size="icon" 192 192 + variant="ghost" 193 193 + type="button" 194 194 + onClick={() => remove(index)} 195 195 + > 196 196 + <X className="h-4 w-4" /> 197 197 + </Button> 198 198 + </div> 199 199 + </div> 200 200 + ))} 201 201 + <div> 202 202 + <Button 203 203 + type="button" 204 204 + variant="outline" 205 205 + onClick={() => append({ key: "", value: "" })} 206 206 + > 207 207 + Add Custom Header 208 208 + </Button> 209 209 + </div> 210 210 + </div> 211 211 + {watchMethod === "POST" && ( 212 212 + <div className="sm:col-span-full"> 213 213 + <FormField 214 214 + control={form.control} 215 215 + name="body" 216 216 + render={({ field }) => ( 217 217 + <FormItem className="space-y-1.5"> 218 218 + <div className="flex items-end justify-between"> 219 219 + <FormLabel className="flex items-center space-x-2"> 220 220 + Body 221 221 + <Select 222 222 + defaultValue={content} 223 223 + onValueChange={(value) => { 224 224 + setContent(value); 225 225 + 226 226 + if (content === "application/octet-stream") { 227 227 + form.setValue("body", ""); 228 228 + setFile(undefined); 229 229 + } 230 230 + 231 231 + const contentIndex = fields.findIndex( 232 232 + (field) => field.key === "Content-Type", 233 233 + ); 234 234 + 235 235 + if (contentIndex >= 0) { 236 236 + if (value === "none") { 237 237 + remove(contentIndex); 238 238 + } else { 239 239 + update(contentIndex, { 240 240 + key: "Content-Type", 241 241 + value, 242 242 + }); 243 243 + } 244 244 + } else { 245 245 + prepend({ key: "Content-Type", value }); 246 246 + } 247 247 + }} 248 248 + > 249 249 + <SelectTrigger 250 250 + variant={"ghost"} 251 251 + className="ml-1 h-7 text-muted-foreground text-xs" 252 252 + > 253 253 + <SelectValue placeholder="Content-Type" /> 254 254 + </SelectTrigger> 255 255 + <SelectContent> 256 256 + {contentTypes.map((type) => ( 257 257 + <SelectItem key={type.value} value={type.value}> 258 258 + {type.label} 259 259 + </SelectItem> 260 260 + ))} 261 261 + </SelectContent> 262 262 + </Select> 263 263 + </FormLabel> 264 264 + {watchMethod === "POST" && 265 265 + fields.some( 266 266 + (field) => 267 267 + field.key === "Content-Type" && 268 268 + field.value === "application/json", 269 269 + ) && ( 270 270 + <TooltipProvider> 271 271 + <Tooltip> 272 272 + <TooltipTrigger asChild> 273 273 + <Button 274 274 + type="button" 275 275 + variant="ghost" 276 276 + size="icon" 277 277 + className="h-7 w-7" 278 278 + onClick={onPrettifyJSON} 279 279 + > 280 280 + <Wand2 className="h-3 w-3" /> 281 281 + </Button> 282 282 + </TooltipTrigger> 283 283 + <TooltipContent> 284 284 + <p>Prettify JSON</p> 285 285 + </TooltipContent> 286 286 + </Tooltip> 287 287 + </TooltipProvider> 288 288 + )} 289 289 + </div> 290 290 + <div className="space-y-2"> 291 291 + <FormControl> 292 292 + {content === "application/octet-stream" ? ( 293 293 + <> 294 294 + <Button 295 295 + type="button" 296 296 + variant="outline" 297 297 + onClick={() => inputRef.current?.click()} 298 298 + className="max-w-56" 299 299 + > 300 300 + <span className="truncate"> 301 301 + {file || form.getValues("body") || "Upload file"} 302 302 + </span> 303 303 + </Button> 304 304 + <input 305 305 + type="file" 306 306 + onChange={uploadFile} 307 307 + ref={inputRef} 308 308 + hidden 309 309 + /> 310 310 + </> 311 311 + ) : ( 312 312 + <> 313 313 + <Textarea 314 314 + rows={8} 315 315 + placeholder='{ "hello": "world" }' 316 316 + {...field} 317 317 + /> 318 318 + <FormDescription>Write your payload.</FormDescription> 319 319 + </> 320 320 + )} 321 321 + </FormControl> 322 322 + <FormMessage /> 323 323 + </div> 324 324 + </FormItem> 325 325 + )} 326 326 + /> 327 327 + </div> 328 328 + )} 329 329 + </div> 330 330 + ); 331 331 + }

+67

apps/web/src/components/forms/monitor/section-request-tcp.tsx

··· 1 1 + "use client"; 2 2 + 3 3 + import * as React from "react"; 4 4 + import type { UseFormReturn } from "react-hook-form"; 5 5 + 6 6 + import type { InsertMonitor } from "@openstatus/db/src/schema"; 7 7 + import { 8 8 + FormControl, 9 9 + FormDescription, 10 10 + FormField, 11 11 + FormItem, 12 12 + FormLabel, 13 13 + FormMessage, 14 14 + Input, 15 15 + } from "@openstatus/ui"; 16 16 + 17 17 + // TODO: add `port` and `host` field instead! 18 18 + 19 19 + interface Props { 20 20 + form: UseFormReturn<InsertMonitor>; 21 21 + } 22 22 + 23 23 + export function SectionRequestTCP({ form }: Props) { 24 24 + return ( 25 25 + <div className="grid w-full gap-4"> 26 26 + <div className="grid gap-4 sm:grid-cols-7"> 27 27 + <FormField 28 28 + control={form.control} 29 29 + name="url" 30 30 + render={({ field }) => ( 31 31 + <FormItem className="sm:col-span-5"> 32 32 + <FormLabel>Host:Port</FormLabel> 33 33 + <FormControl> 34 34 + <Input 35 35 + className="bg-muted" 36 36 + placeholder="192.168.1.1:80" 37 37 + {...field} 38 38 + /> 39 39 + </FormControl> 40 40 + <FormMessage /> 41 41 + <FormDescription> 42 42 + The input supports both IPv4 addresses and IPv6 addresses. 43 43 + </FormDescription> 44 44 + </FormItem> 45 45 + )} 46 46 + /> 47 47 + </div> 48 48 + <div className="text-sm"> 49 49 + <p>Examples:</p> 50 50 + <ul className="list-inside list-disc text-muted-foreground"> 51 51 + <li> 52 52 + Domain: <code className="text-foreground">openstatus.dev:443</code> 53 53 + </li> 54 54 + <li> 55 55 + IPv4: <code className="text-foreground">192.168.1.1:443</code> 56 56 + </li> 57 57 + <li> 58 58 + IPv6:{" "} 59 59 + <code className="text-foreground"> 60 60 + [2001:db8:85a3:8d3:1319:8a2e:370:7348]:443 61 61 + </code> 62 62 + </li> 63 63 + </ul> 64 64 + </div> 65 65 + </div> 66 66 + ); 67 67 + }

+106 -313

apps/web/src/components/forms/monitor/section-requests.tsx

··· 1 1 "use client"; 2 2 3 3 - import { Wand2, X } from "lucide-react"; 4 4 - import type * as React from "react"; 5 5 - import { useFieldArray } from "react-hook-form"; 3 3 + import * as React from "react"; 6 4 import type { UseFormReturn } from "react-hook-form"; 7 5 8 8 - import { 9 9 - monitorMethods, 10 10 - monitorMethodsSchema, 11 11 - } from "@openstatus/db/src/schema"; 6 6 + import { monitorJobTypesSchema } from "@openstatus/db/src/schema"; 12 7 import type { InsertMonitor } from "@openstatus/db/src/schema"; 8 8 + 13 9 import { 14 14 - Button, 15 15 - FormControl, 16 16 - FormDescription, 17 17 - FormField, 18 18 - FormItem, 19 19 - FormLabel, 20 20 - FormMessage, 21 21 - Input, 22 22 - Select, 23 23 - SelectContent, 24 24 - SelectItem, 25 25 - SelectTrigger, 26 26 - SelectValue, 27 27 - Textarea, 28 28 - Tooltip, 29 29 - TooltipContent, 30 30 - TooltipProvider, 31 31 - TooltipTrigger, 32 32 - } from "@openstatus/ui"; 10 10 + Tabs, 11 11 + TabsContent, 12 12 + TabsList, 13 13 + TabsTrigger, 14 14 + } from "@/components/dashboard/tabs"; 33 15 34 34 - import { toast } from "@/lib/toast"; 35 35 - import { useRef, useState } from "react"; 16 16 + import { Alert, AlertDescription, AlertTitle, Badge } from "@openstatus/ui"; 36 17 import { SectionHeader } from "../shared/section-header"; 37 37 - 38 38 - const contentTypes = [ 39 39 - { value: "application/octet-stream", label: "Binary File" }, 40 40 - { value: "application/json", label: "JSON" }, 41 41 - { value: "application/xml", label: "XML" }, 42 42 - { value: "application/yaml", label: "YAML" }, 43 43 - { value: "application/edn", label: "EDN" }, 44 44 - { value: "application/other", label: "Other" }, 45 45 - { value: "none", label: "None" }, 46 46 - ]; 18 18 + import { SectionRequestHTTP } from "./section-request-http"; 19 19 + import { SectionRequestTCP } from "./section-request-tcp"; 47 20 48 21 interface Props { 49 22 form: UseFormReturn<InsertMonitor>; 23 23 + type: "create" | "update"; 50 24 } 51 25 52 26 // TODO: add Dialog with response informations when pingEndpoint! 53 27 54 54 - export function SectionRequests({ form }: Props) { 55 55 - const { fields, append, prepend, remove, update } = useFieldArray({ 56 56 - name: "headers", 57 57 - control: form.control, 58 58 - }); 59 59 - const inputRef = useRef<HTMLInputElement>(null); 60 60 - const watchMethod = form.watch("method"); 61 61 - const [file, setFile] = useState<string | undefined>(undefined); 62 62 - const [content, setContent] = useState<string | undefined>( 63 63 - fields.find((field) => field.key === "Content-Type")?.value, 64 64 - ); 28 28 + export function SectionRequests({ form, type }: Props) { 29 29 + const jobType = form.getValues("jobType"); 30 30 + const [prevJobType, setPrevJobType] = React.useState(jobType); 65 31 66 66 - const validateJSON = (value?: string) => { 67 67 - if (!value) return; 68 68 - try { 69 69 - const obj = JSON.parse(value) as Record<string, unknown>; 70 70 - form.clearErrors("body"); 71 71 - return obj; 72 72 - } catch (_e) { 73 73 - form.setError("body", { 74 74 - message: "Not a valid JSON object", 75 75 - }); 76 76 - return false; 77 77 - } 78 78 - }; 79 79 - 80 80 - const uploadFile = async (event: React.ChangeEvent<HTMLInputElement>) => { 81 81 - if (event.target.files?.[0]) { 82 82 - const file = event.target.files[0]; 83 83 - 84 84 - // File too big, return error 85 85 - const fileSize = file.size / 1024 / 1024; // in MiB 86 86 - if (fileSize > 10) { 87 87 - // Display error message 88 88 - toast.error("File size is too big. Max 10MB allowed."); 89 89 - return; 90 90 - } 91 91 - 92 92 - const reader = new FileReader(); 93 93 - reader.onload = (event) => { 94 94 - if (event.target?.result && typeof event.target.result === "string") { 95 95 - form.setValue("body", event.target?.result); 96 96 - setFile(file.name); 97 97 - } 98 98 - }; 99 99 - 100 100 - reader.readAsDataURL(file); 101 101 - } 102 102 - }; 103 103 - 104 104 - const onPrettifyJSON = () => { 105 105 - const body = form.getValues("body"); 106 106 - const obj = validateJSON(body); 107 107 - if (obj) { 108 108 - const pretty = JSON.stringify(obj, undefined, 4); 109 109 - form.setValue("body", pretty); 32 32 + if (prevJobType !== jobType) { 33 33 + setPrevJobType(jobType); 34 34 + if (type === "create") { 35 35 + form.resetField("url"); 36 36 + form.resetField("method"); 37 37 + form.resetField("body"); 38 38 + form.resetField("headers"); 39 39 + form.resetField("headerAssertions"); 40 40 + form.resetField("statusAssertions"); 41 41 + form.resetField("textBodyAssertions"); 110 42 } 111 111 - }; 43 43 + } 112 44 113 45 return ( 114 46 <div className="grid w-full gap-4"> 115 47 <SectionHeader 116 116 - title="HTTP Request Settings" 117 117 - description="Create your HTTP. Add custom headers, payload and test your endpoint before submitting." 48 48 + title="Request Settings" 49 49 + description={ 50 50 + type === "create" ? ( 51 51 + <> 52 52 + Create your{" "} 53 53 + <span className="font-medium font-mono text-foreground"> 54 54 + HTTP 55 55 + </span>{" "} 56 56 + or{" "} 57 57 + <span className="font-medium font-mono text-foreground">TCP</span>{" "} 58 58 + request type. Add custom headers, payload and test your endpoint 59 59 + before submitting.{" "} 60 60 + <span className="font-medium"> 61 61 + You will not be able to switch type after saving. 62 62 + </span> 63 63 + </> 64 64 + ) : ( 65 65 + <> 66 66 + Update your{" "} 67 67 + <span className="font-medium font-mono text-foreground"> 68 68 + {jobType?.toUpperCase()} 69 69 + </span>{" "} 70 70 + request. Add custom headers, payload and test your endpoint before 71 71 + submitting. 72 72 + </> 73 73 + ) 74 74 + } 118 75 /> 119 119 - <div className="grid gap-4 sm:grid-cols-7"> 120 120 - <FormField 121 121 - control={form.control} 122 122 - name="method" 123 123 - render={({ field }) => ( 124 124 - <FormItem className="sm:col-span-1"> 125 125 - <FormLabel>Method</FormLabel> 126 126 - <Select 127 127 - onValueChange={(value) => { 128 128 - field.onChange(monitorMethodsSchema.parse(value)); 129 129 - form.resetField("body", { defaultValue: "" }); 130 130 - setContent(undefined); 131 131 - }} 132 132 - defaultValue={field.value} 133 133 - > 134 134 - <FormControl> 135 135 - <SelectTrigger> 136 136 - <SelectValue placeholder="Select" /> 137 137 - </SelectTrigger> 138 138 - </FormControl> 139 139 - <SelectContent> 140 140 - {monitorMethods.map((method) => ( 141 141 - <SelectItem key={method} value={method}> 142 142 - {method} 143 143 - </SelectItem> 144 144 - ))} 145 145 - </SelectContent> 146 146 - </Select> 147 147 - <FormMessage /> 148 148 - </FormItem> 149 149 - )} 150 150 - /> 151 151 - <FormField 152 152 - control={form.control} 153 153 - name="url" 154 154 - render={({ field }) => ( 155 155 - <FormItem className="sm:col-span-6"> 156 156 - <FormLabel>URL</FormLabel> 157 157 - <FormControl> 158 158 - <Input 159 159 - className="bg-muted" 160 160 - placeholder="https://documenso.com/api/health" 161 161 - {...field} 162 162 - /> 163 163 - </FormControl> 164 164 - </FormItem> 165 165 - )} 166 166 - /> 167 167 - </div> 168 168 - <div className="space-y-2 sm:col-span-full"> 169 169 - <FormLabel>Request Header</FormLabel> 170 170 - {fields.map((field, index) => ( 171 171 - <div key={field.id} className="grid grid-cols-6 gap-4"> 172 172 - <FormField 173 173 - control={form.control} 174 174 - name={`headers.${index}.key`} 175 175 - render={({ field }) => ( 176 176 - <FormItem className="col-span-2"> 177 177 - <FormControl> 178 178 - <Input placeholder="key" {...field} /> 179 179 - </FormControl> 180 180 - </FormItem> 181 181 - )} 182 182 - /> 183 183 - <div className="col-span-4 flex items-center space-x-2"> 184 184 - <FormField 185 185 - control={form.control} 186 186 - name={`headers.${index}.value`} 187 187 - render={({ field }) => ( 188 188 - <FormItem className="w-full"> 189 189 - <FormControl> 190 190 - <Input placeholder="value" {...field} /> 191 191 - </FormControl> 192 192 - </FormItem> 193 193 - )} 194 194 - /> 195 195 - <Button 196 196 - size="icon" 197 197 - variant="ghost" 198 198 - type="button" 199 199 - onClick={() => { 200 200 - remove(index); 201 201 - }} 202 202 - > 203 203 - <X className="h-4 w-4" /> 204 204 - </Button> 205 205 - </div> 206 206 - </div> 207 207 - ))} 208 208 - <div> 209 209 - <Button 210 210 - type="button" 211 211 - variant="outline" 212 212 - onClick={() => append({ key: "", value: "" })} 213 213 - > 214 214 - Add Custom Header 215 215 - </Button> 216 216 - </div> 217 217 - </div> 218 218 - {watchMethod === "POST" && ( 219 219 - <div className="sm:col-span-full"> 220 220 - <FormField 221 221 - control={form.control} 222 222 - name="body" 223 223 - render={({ field }) => ( 224 224 - <FormItem className="space-y-1.5"> 225 225 - <div className="flex items-end justify-between"> 226 226 - <FormLabel className="flex items-center space-x-2"> 227 227 - Body 228 228 - <Select 229 229 - defaultValue={content} 230 230 - onValueChange={(value) => { 231 231 - setContent(value); 232 232 - 233 233 - if (content === "application/octet-stream") { 234 234 - form.setValue("body", ""); 235 235 - setFile(undefined); 236 236 - } 237 237 - 238 238 - const contentIndex = fields.findIndex( 239 239 - (field) => field.key === "Content-Type", 240 240 - ); 241 241 - 242 242 - if (contentIndex >= 0) { 243 243 - if (value === "none") { 244 244 - remove(contentIndex); 245 245 - } else { 246 246 - update(contentIndex, { 247 247 - key: "Content-Type", 248 248 - value, 249 249 - }); 250 250 - } 251 251 - } else { 252 252 - prepend({ key: "Content-Type", value }); 253 253 - } 254 254 - }} 255 255 - > 256 256 - <SelectTrigger 257 257 - variant={"ghost"} 258 258 - className="ml-1 h-7 text-muted-foreground text-xs" 259 259 - > 260 260 - <SelectValue placeholder="Content-Type" /> 261 261 - </SelectTrigger> 262 262 - <SelectContent> 263 263 - {contentTypes.map((type) => ( 264 264 - <SelectItem key={type.value} value={type.value}> 265 265 - {type.label} 266 266 - </SelectItem> 267 267 - ))} 268 268 - </SelectContent> 269 269 - </Select> 270 270 - </FormLabel> 271 271 - {watchMethod === "POST" && 272 272 - fields.some( 273 273 - (field) => 274 274 - field.key === "Content-Type" && 275 275 - field.value === "application/json", 276 276 - ) && ( 277 277 - <TooltipProvider> 278 278 - <Tooltip> 279 279 - <TooltipTrigger asChild> 280 280 - <Button 281 281 - type="button" 282 282 - variant="ghost" 283 283 - size="icon" 284 284 - className="h-7 w-7" 285 285 - onClick={onPrettifyJSON} 286 286 - > 287 287 - <Wand2 className="h-3 w-3" /> 288 288 - </Button> 289 289 - </TooltipTrigger> 290 290 - <TooltipContent> 291 291 - <p>Prettify JSON</p> 292 292 - </TooltipContent> 293 293 - </Tooltip> 294 294 - </TooltipProvider> 295 295 - )} 296 296 - </div> 297 297 - <div className="space-y-2"> 298 298 - <FormControl> 299 299 - {content === "application/octet-stream" ? ( 300 300 - <> 301 301 - <Button 302 302 - type="button" 303 303 - variant="outline" 304 304 - onClick={() => inputRef.current?.click()} 305 305 - className="max-w-56" 306 306 - > 307 307 - <span className="truncate"> 308 308 - {file || form.getValues("body") || "Upload file"} 309 309 - </span> 310 310 - </Button> 311 311 - <input 312 312 - type="file" 313 313 - onChange={uploadFile} 314 314 - ref={inputRef} 315 315 - hidden 316 316 - /> 317 317 - </> 318 318 - ) : ( 319 319 - <> 320 320 - <Textarea 321 321 - rows={8} 322 322 - placeholder='{ "hello": "world" }' 323 323 - {...field} 324 324 - /> 325 325 - <FormDescription>Write your payload.</FormDescription> 326 326 - </> 327 327 - )} 328 328 - </FormControl> 329 329 - <FormMessage /> 330 330 - </div> 331 331 - </FormItem> 332 332 - )} 333 333 - /> 334 334 - </div> 335 335 - )} 76 76 + {type === "create" ? ( 77 77 + <Tabs 78 78 + value={jobType} 79 79 + onValueChange={(value) => { 80 80 + const validate = monitorJobTypesSchema.safeParse(value); 81 81 + if (!validate.success) return; 82 82 + form.setValue("jobType", validate.data, { 83 83 + shouldDirty: true, 84 84 + shouldTouch: true, 85 85 + shouldValidate: true, 86 86 + }); 87 87 + }} 88 88 + > 89 89 + <TabsList> 90 90 + <TabsTrigger value="http">HTTP</TabsTrigger> 91 91 + <TabsTrigger value="tcp" disabled={true}> 92 92 + TCP{" "} 93 93 + <Badge className="ml-2" variant="default"> 94 94 + Coming soon 95 95 + </Badge> 96 96 + </TabsTrigger> 97 97 + </TabsList> 98 98 + <TabsContent value="http"> 99 99 + <SectionRequestHTTP {...{ form }} /> 100 100 + </TabsContent> 101 101 + <TabsContent value="tcp"> 102 102 + <SectionRequestTCP {...{ form }} /> 103 103 + </TabsContent> 104 104 + </Tabs> 105 105 + ) : null} 106 106 + {type === "update" 107 107 + ? (() => { 108 108 + switch (jobType) { 109 109 + case "http": 110 110 + return <SectionRequestHTTP {...{ form }} />; 111 111 + case "tcp": 112 112 + return <SectionRequestTCP {...{ form }} />; 113 113 + default: 114 114 + return ( 115 115 + <Alert> 116 116 + <AlertTitle>Missing Type</AlertTitle> 117 117 + <AlertDescription> 118 118 + The job type{" "} 119 119 + <span className="font-mono text-foreground uppercase"> 120 120 + {jobType} 121 121 + </span>{" "} 122 122 + is missing. Please select a valid job type. 123 123 + </AlertDescription> 124 124 + </Alert> 125 125 + ); 126 126 + } 127 127 + })() 128 128 + : null} 336 129 </div> 337 130 ); 338 131 }

+22 -12

apps/web/src/components/forms/monitor/section-scheduling.tsx

··· 24 24 import type { Limits } from "@openstatus/db/src/schema/plan/schema"; 25 25 import { CheckboxLabel } from "../shared/checkbox-label"; 26 26 import { SectionHeader } from "../shared/section-header"; 27 27 + import { SelectRegion } from "./select-region"; 27 28 28 29 // TODO: centralize in a shared file! 29 30 const cronJobs = [ ··· 95 96 render={({ field }) => { 96 97 return ( 97 98 <FormItem> 98 98 - <div className="mb-4"> 99 99 - <FormLabel className="text-base">Regions</FormLabel> 100 100 - <FormDescription> 101 101 - Select the regions you want to monitor your endpoint from.{" "} 102 102 - <br /> 103 103 - {plan === "free" 104 104 - ? "Only a few regions are available in the free plan. Upgrade to access all regions." 105 105 - : ""} 106 106 - </FormDescription> 99 99 + <FormLabel className="text-base">Regions</FormLabel> 100 100 + <div> 101 101 + <FormControl> 102 102 + <SelectRegion 103 103 + value={field.value} 104 104 + allowedRegions={regionsLimit} 105 105 + onChange={field.onChange} 106 106 + /> 107 107 + </FormControl> 107 108 </div> 109 109 + <FormDescription> 110 110 + Select the regions you want to monitor your endpoint from.{" "} 111 111 + <br /> 112 112 + {plan === "free" 113 113 + ? "Only a few regions are available in the free plan. Upgrade to access all regions." 114 114 + : ""} 115 115 + </FormDescription> 108 116 <div> 109 117 {Object.entries(groupByContinent) 110 118 .sort((a, b) => a[0].localeCompare(b[0])) ··· 114 122 .map((current) => { 115 123 return ( 116 124 <div key={current.continent} className="py-2"> 117 117 - {current.continent} 118 118 - 119 119 - <div className="grid grid-cols-3 grid-rows-1 gap-2 pt-1"> 125 125 + <p className="font-medium text-muted-foreground text-sm"> 126 126 + {current.continent} 127 127 + </p> 128 128 + <div className="grid grid-cols-3 gap-2"> 120 129 {current.regions 121 130 .sort((a, b) => 122 131 a.location.localeCompare(b.location), ··· 160 169 ), 161 170 ); 162 171 }} 172 172 + className="p-3" 163 173 > 164 174 {location} {flag} 165 175 </CheckboxLabel>

+142

apps/web/src/components/forms/monitor/select-region.tsx

··· 1 1 + "use client"; 2 2 + 3 3 + import { Check, ChevronsUpDown, Globe2 } from "lucide-react"; 4 4 + import * as React from "react"; 5 5 + 6 6 + import type { Region } from "@openstatus/tinybird"; 7 7 + import { Button, type ButtonProps } from "@openstatus/ui/src/components/button"; 8 8 + import { 9 9 + Command, 10 10 + CommandEmpty, 11 11 + CommandGroup, 12 12 + CommandInput, 13 13 + CommandItem, 14 14 + CommandList, 15 15 + CommandSeparator, 16 16 + } from "@openstatus/ui/src/components/command"; 17 17 + import { 18 18 + Popover, 19 19 + PopoverContent, 20 20 + PopoverTrigger, 21 21 + } from "@openstatus/ui/src/components/popover"; 22 22 + import { 23 23 + type Continent, 24 24 + type RegionInfo, 25 25 + flyRegionsDict, 26 26 + } from "@openstatus/utils"; 27 27 + 28 28 + import { cn } from "@/lib/utils"; 29 29 + import { flyRegions } from "@openstatus/db/src/schema/constants"; 30 30 + 31 31 + interface SelectRegionProps extends Omit<ButtonProps, "onChange"> { 32 32 + allowedRegions: Region[]; 33 33 + value?: Region[]; 34 34 + onChange?: (value: Region[]) => void; 35 35 + } 36 36 + 37 37 + export function SelectRegion({ 38 38 + value = [], 39 39 + onChange, 40 40 + allowedRegions, 41 41 + className, 42 42 + ...props 43 43 + }: SelectRegionProps) { 44 44 + const regionsByContinent = flyRegions.reduce( 45 45 + (prev, curr) => { 46 46 + const region = flyRegionsDict[curr]; 47 47 + 48 48 + const item = prev.find((r) => r.continent === region.continent); 49 49 + 50 50 + if (item) { 51 51 + item.data.push(region); 52 52 + } else { 53 53 + prev.push({ 54 54 + continent: region.continent, 55 55 + data: [region], 56 56 + }); 57 57 + } 58 58 + 59 59 + return prev; 60 60 + }, 61 61 + [] as { continent: Continent; data: RegionInfo[] }[], 62 62 + ); 63 63 + 64 64 + return ( 65 65 + <Popover> 66 66 + <PopoverTrigger asChild> 67 67 + <Button 68 68 + size="lg" 69 69 + variant="outline" 70 70 + className={cn("px-3 shadow-none", className)} 71 71 + {...props} 72 72 + > 73 73 + <Globe2 className="mr-2 h-4 w-4" /> 74 74 + <span className="whitespace-nowrap"> 75 75 + <code>{value.length}</code> Regions 76 76 + </span> 77 77 + <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" /> 78 78 + </Button> 79 79 + </PopoverTrigger> 80 80 + <PopoverContent className="p-0" align="start"> 81 81 + <Command> 82 82 + <CommandInput placeholder="Search regions..." /> 83 83 + <CommandList className="max-h-64"> 84 84 + <CommandEmpty>No results found.</CommandEmpty> 85 85 + <CommandGroup> 86 86 + <CommandItem 87 87 + onSelect={() => onChange?.(value.length ? [] : allowedRegions)} 88 88 + > 89 89 + {value.length ? "Clear all" : "Select all"} 90 90 + </CommandItem> 91 91 + </CommandGroup> 92 92 + <CommandSeparator /> 93 93 + {regionsByContinent.map(({ continent, data }) => { 94 94 + return ( 95 95 + <CommandGroup key={continent} heading={continent}> 96 96 + {data.map((region) => { 97 97 + const { code, flag, location, continent } = region; 98 98 + const isSelected = value.includes(code); 99 99 + return ( 100 100 + <CommandItem 101 101 + key={code} 102 102 + value={code} 103 103 + keywords={[code, location, continent]} 104 104 + disabled={!allowedRegions.includes(code)} 105 105 + onSelect={(checked) => { 106 106 + const newValue = !value.includes(checked as Region) 107 107 + ? [...value, code] 108 108 + : value.filter((r) => r !== code); 109 109 + onChange?.(newValue); 110 110 + }} 111 111 + > 112 112 + <div 113 113 + className={cn( 114 114 + "mr-2 flex h-4 w-4 items-center justify-center rounded-sm border border-primary", 115 115 + isSelected 116 116 + ? "bg-primary text-primary-foreground" 117 117 + : "opacity-50 [&_svg]:invisible", 118 118 + )} 119 119 + > 120 120 + <Check className={cn("h-4 w-4")} /> 121 121 + </div> 122 122 + <div className="flex w-full justify-between"> 123 123 + <span> 124 124 + {code}{" "} 125 125 + <span className="truncate text-muted-foreground"> 126 126 + {location} 127 127 + </span> 128 128 + </span> 129 129 + <span>{flag}</span> 130 130 + </div> 131 131 + </CommandItem> 132 132 + ); 133 133 + })} 134 134 + </CommandGroup> 135 135 + ); 136 136 + })} 137 137 + </CommandList> 138 138 + </Command> 139 139 + </PopoverContent> 140 140 + </Popover> 141 141 + ); 142 142 + }

+5 -3

apps/web/src/components/forms/monitor/tags-multi-box.tsx

··· 366 366 <AlertDialogContent> 367 367 <AlertDialogHeader> 368 368 <AlertDialogTitle>Are you sure sure?</AlertDialogTitle> 369 369 - <AlertDialogDescription> 370 370 - You are about to delete the tag{" "} 371 371 - <TagBadge color={color} name={name} /> . 369 369 + <AlertDialogDescription asChild> 370 370 + <div> 371 371 + You are about to delete the tag{" "} 372 372 + <TagBadge color={color} name={name} /> . 373 373 + </div> 372 374 </AlertDialogDescription> 373 375 </AlertDialogHeader> 374 376 <AlertDialogFooter>

+1 -1

apps/web/src/components/forms/shared/checkbox-label.tsx

··· 36 36 <Label 37 37 htmlFor={`${name}-${id}`} 38 38 className={cn( 39 39 - "flex h-full items-center gap-1 rounded-md border border-border bg-popover p-4 pr-10 hover:bg-accent hover:text-accent-foreground peer-data-[state=checked]:border-primary [&:has([data-state=checked])]:border-primary", 39 39 + "flex h-full items-center gap-1 rounded-md border border-border bg-popover p-4 pr-10 hover:bg-accent hover:text-accent-foreground peer-data-[state=checked]:border-primary [&:has([data-state=checked])]:border-primary peer-disabled:hover:bg-background peer-disabled:text-muted-foreground", 40 40 className, 41 41 )} 42 42 >

+1 -1

package.json

··· 4 4 "build": "turbo run build", 5 5 "dev": "turbo run dev", 6 6 "lint": "biome lint .", 7 7 - "format": "pnpm biome format . --write && pnpm biome check . --apply-unsafe ", 7 7 + "format": "pnpm biome format . --write && pnpm biome check . --write ", 8 8 "lint:turbo": "turbo run lint", 9 9 "dev:web": "turbo run dev --filter='./apps/web' --filter='./packages/db'", 10 10 "dx": "turbo run dx",

+1

packages/db/drizzle/0036_gifted_deathbird.sql

··· 1 1 + UPDATE `monitor` SET `job_type` = 'http' ;

+2197

packages/db/drizzle/meta/0036_snapshot.json

··· 1 1 + { 2 2 + "version": "6", 3 3 + "dialect": "sqlite", 4 4 + "id": "7321a546-31be-4313-8e3f-235db16ddee4", 5 5 + "prevId": "d42f0027-40b6-4d43-9d76-160e0a6e35e7", 6 6 + "tables": { 7 7 + "status_report_to_monitors": { 8 8 + "name": "status_report_to_monitors", 9 9 + "columns": { 10 10 + "monitor_id": { 11 11 + "name": "monitor_id", 12 12 + "type": "integer", 13 13 + "primaryKey": false, 14 14 + "notNull": true, 15 15 + "autoincrement": false 16 16 + }, 17 17 + "status_report_id": { 18 18 + "name": "status_report_id", 19 19 + "type": "integer", 20 20 + "primaryKey": false, 21 21 + "notNull": true, 22 22 + "autoincrement": false 23 23 + }, 24 24 + "created_at": { 25 25 + "name": "created_at", 26 26 + "type": "integer", 27 27 + "primaryKey": false, 28 28 + "notNull": false, 29 29 + "autoincrement": false, 30 30 + "default": "(strftime('%s', 'now'))" 31 31 + } 32 32 + }, 33 33 + "indexes": {}, 34 34 + "foreignKeys": { 35 35 + "status_report_to_monitors_monitor_id_monitor_id_fk": { 36 36 + "name": "status_report_to_monitors_monitor_id_monitor_id_fk", 37 37 + "tableFrom": "status_report_to_monitors", 38 38 + "tableTo": "monitor", 39 39 + "columnsFrom": [ 40 40 + "monitor_id" 41 41 + ], 42 42 + "columnsTo": [ 43 43 + "id" 44 44 + ], 45 45 + "onDelete": "cascade", 46 46 + "onUpdate": "no action" 47 47 + }, 48 48 + "status_report_to_monitors_status_report_id_status_report_id_fk": { 49 49 + "name": "status_report_to_monitors_status_report_id_status_report_id_fk", 50 50 + "tableFrom": "status_report_to_monitors", 51 51 + "tableTo": "status_report", 52 52 + "columnsFrom": [ 53 53 + "status_report_id" 54 54 + ], 55 55 + "columnsTo": [ 56 56 + "id" 57 57 + ], 58 58 + "onDelete": "cascade", 59 59 + "onUpdate": "no action" 60 60 + } 61 61 + }, 62 62 + "compositePrimaryKeys": { 63 63 + "status_report_to_monitors_monitor_id_status_report_id_pk": { 64 64 + "columns": [ 65 65 + "monitor_id", 66 66 + "status_report_id" 67 67 + ], 68 68 + "name": "status_report_to_monitors_monitor_id_status_report_id_pk" 69 69 + } 70 70 + }, 71 71 + "uniqueConstraints": {} 72 72 + }, 73 73 + "status_report": { 74 74 + "name": "status_report", 75 75 + "columns": { 76 76 + "id": { 77 77 + "name": "id", 78 78 + "type": "integer", 79 79 + "primaryKey": true, 80 80 + "notNull": true, 81 81 + "autoincrement": false 82 82 + }, 83 83 + "status": { 84 84 + "name": "status", 85 85 + "type": "text", 86 86 + "primaryKey": false, 87 87 + "notNull": true, 88 88 + "autoincrement": false 89 89 + }, 90 90 + "title": { 91 91 + "name": "title", 92 92 + "type": "text(256)", 93 93 + "primaryKey": false, 94 94 + "notNull": true, 95 95 + "autoincrement": false 96 96 + }, 97 97 + "workspace_id": { 98 98 + "name": "workspace_id", 99 99 + "type": "integer", 100 100 + "primaryKey": false, 101 101 + "notNull": false, 102 102 + "autoincrement": false 103 103 + }, 104 104 + "page_id": { 105 105 + "name": "page_id", 106 106 + "type": "integer", 107 107 + "primaryKey": false, 108 108 + "notNull": false, 109 109 + "autoincrement": false 110 110 + }, 111 111 + "created_at": { 112 112 + "name": "created_at", 113 113 + "type": "integer", 114 114 + "primaryKey": false, 115 115 + "notNull": false, 116 116 + "autoincrement": false, 117 117 + "default": "(strftime('%s', 'now'))" 118 118 + }, 119 119 + "updated_at": { 120 120 + "name": "updated_at", 121 121 + "type": "integer", 122 122 + "primaryKey": false, 123 123 + "notNull": false, 124 124 + "autoincrement": false, 125 125 + "default": "(strftime('%s', 'now'))" 126 126 + } 127 127 + }, 128 128 + "indexes": {}, 129 129 + "foreignKeys": { 130 130 + "status_report_workspace_id_workspace_id_fk": { 131 131 + "name": "status_report_workspace_id_workspace_id_fk", 132 132 + "tableFrom": "status_report", 133 133 + "tableTo": "workspace", 134 134 + "columnsFrom": [ 135 135 + "workspace_id" 136 136 + ], 137 137 + "columnsTo": [ 138 138 + "id" 139 139 + ], 140 140 + "onDelete": "no action", 141 141 + "onUpdate": "no action" 142 142 + }, 143 143 + "status_report_page_id_page_id_fk": { 144 144 + "name": "status_report_page_id_page_id_fk", 145 145 + "tableFrom": "status_report", 146 146 + "tableTo": "page", 147 147 + "columnsFrom": [ 148 148 + "page_id" 149 149 + ], 150 150 + "columnsTo": [ 151 151 + "id" 152 152 + ], 153 153 + "onDelete": "no action", 154 154 + "onUpdate": "no action" 155 155 + } 156 156 + }, 157 157 + "compositePrimaryKeys": {}, 158 158 + "uniqueConstraints": {} 159 159 + }, 160 160 + "status_report_update": { 161 161 + "name": "status_report_update", 162 162 + "columns": { 163 163 + "id": { 164 164 + "name": "id", 165 165 + "type": "integer", 166 166 + "primaryKey": true, 167 167 + "notNull": true, 168 168 + "autoincrement": false 169 169 + }, 170 170 + "status": { 171 171 + "name": "status", 172 172 + "type": "text(4)", 173 173 + "primaryKey": false, 174 174 + "notNull": true, 175 175 + "autoincrement": false 176 176 + }, 177 177 + "date": { 178 178 + "name": "date", 179 179 + "type": "integer", 180 180 + "primaryKey": false, 181 181 + "notNull": true, 182 182 + "autoincrement": false 183 183 + }, 184 184 + "message": { 185 185 + "name": "message", 186 186 + "type": "text", 187 187 + "primaryKey": false, 188 188 + "notNull": true, 189 189 + "autoincrement": false 190 190 + }, 191 191 + "status_report_id": { 192 192 + "name": "status_report_id", 193 193 + "type": "integer", 194 194 + "primaryKey": false, 195 195 + "notNull": true, 196 196 + "autoincrement": false 197 197 + }, 198 198 + "created_at": { 199 199 + "name": "created_at", 200 200 + "type": "integer", 201 201 + "primaryKey": false, 202 202 + "notNull": false, 203 203 + "autoincrement": false, 204 204 + "default": "(strftime('%s', 'now'))" 205 205 + }, 206 206 + "updated_at": { 207 207 + "name": "updated_at", 208 208 + "type": "integer", 209 209 + "primaryKey": false, 210 210 + "notNull": false, 211 211 + "autoincrement": false, 212 212 + "default": "(strftime('%s', 'now'))" 213 213 + } 214 214 + }, 215 215 + "indexes": {}, 216 216 + "foreignKeys": { 217 217 + "status_report_update_status_report_id_status_report_id_fk": { 218 218 + "name": "status_report_update_status_report_id_status_report_id_fk", 219 219 + "tableFrom": "status_report_update", 220 220 + "tableTo": "status_report", 221 221 + "columnsFrom": [ 222 222 + "status_report_id" 223 223 + ], 224 224 + "columnsTo": [ 225 225 + "id" 226 226 + ], 227 227 + "onDelete": "cascade", 228 228 + "onUpdate": "no action" 229 229 + } 230 230 + }, 231 231 + "compositePrimaryKeys": {}, 232 232 + "uniqueConstraints": {} 233 233 + }, 234 234 + "integration": { 235 235 + "name": "integration", 236 236 + "columns": { 237 237 + "id": { 238 238 + "name": "id", 239 239 + "type": "integer", 240 240 + "primaryKey": true, 241 241 + "notNull": true, 242 242 + "autoincrement": false 243 243 + }, 244 244 + "name": { 245 245 + "name": "name", 246 246 + "type": "text(256)", 247 247 + "primaryKey": false, 248 248 + "notNull": true, 249 249 + "autoincrement": false 250 250 + }, 251 251 + "workspace_id": { 252 252 + "name": "workspace_id", 253 253 + "type": "integer", 254 254 + "primaryKey": false, 255 255 + "notNull": false, 256 256 + "autoincrement": false 257 257 + }, 258 258 + "credential": { 259 259 + "name": "credential", 260 260 + "type": "text", 261 261 + "primaryKey": false, 262 262 + "notNull": false, 263 263 + "autoincrement": false 264 264 + }, 265 265 + "external_id": { 266 266 + "name": "external_id", 267 267 + "type": "text", 268 268 + "primaryKey": false, 269 269 + "notNull": true, 270 270 + "autoincrement": false 271 271 + }, 272 272 + "created_at": { 273 273 + "name": "created_at", 274 274 + "type": "integer", 275 275 + "primaryKey": false, 276 276 + "notNull": false, 277 277 + "autoincrement": false, 278 278 + "default": "(strftime('%s', 'now'))" 279 279 + }, 280 280 + "updated_at": { 281 281 + "name": "updated_at", 282 282 + "type": "integer", 283 283 + "primaryKey": false, 284 284 + "notNull": false, 285 285 + "autoincrement": false, 286 286 + "default": "(strftime('%s', 'now'))" 287 287 + }, 288 288 + "data": { 289 289 + "name": "data", 290 290 + "type": "text", 291 291 + "primaryKey": false, 292 292 + "notNull": true, 293 293 + "autoincrement": false 294 294 + } 295 295 + }, 296 296 + "indexes": {}, 297 297 + "foreignKeys": { 298 298 + "integration_workspace_id_workspace_id_fk": { 299 299 + "name": "integration_workspace_id_workspace_id_fk", 300 300 + "tableFrom": "integration", 301 301 + "tableTo": "workspace", 302 302 + "columnsFrom": [ 303 303 + "workspace_id" 304 304 + ], 305 305 + "columnsTo": [ 306 306 + "id" 307 307 + ], 308 308 + "onDelete": "no action", 309 309 + "onUpdate": "no action" 310 310 + } 311 311 + }, 312 312 + "compositePrimaryKeys": {}, 313 313 + "uniqueConstraints": {} 314 314 + }, 315 315 + "page": { 316 316 + "name": "page", 317 317 + "columns": { 318 318 + "id": { 319 319 + "name": "id", 320 320 + "type": "integer", 321 321 + "primaryKey": true, 322 322 + "notNull": true, 323 323 + "autoincrement": false 324 324 + }, 325 325 + "workspace_id": { 326 326 + "name": "workspace_id", 327 327 + "type": "integer", 328 328 + "primaryKey": false, 329 329 + "notNull": true, 330 330 + "autoincrement": false 331 331 + }, 332 332 + "title": { 333 333 + "name": "title", 334 334 + "type": "text", 335 335 + "primaryKey": false, 336 336 + "notNull": true, 337 337 + "autoincrement": false 338 338 + }, 339 339 + "description": { 340 340 + "name": "description", 341 341 + "type": "text", 342 342 + "primaryKey": false, 343 343 + "notNull": true, 344 344 + "autoincrement": false 345 345 + }, 346 346 + "icon": { 347 347 + "name": "icon", 348 348 + "type": "text(256)", 349 349 + "primaryKey": false, 350 350 + "notNull": false, 351 351 + "autoincrement": false, 352 352 + "default": "''" 353 353 + }, 354 354 + "slug": { 355 355 + "name": "slug", 356 356 + "type": "text(256)", 357 357 + "primaryKey": false, 358 358 + "notNull": true, 359 359 + "autoincrement": false 360 360 + }, 361 361 + "custom_domain": { 362 362 + "name": "custom_domain", 363 363 + "type": "text(256)", 364 364 + "primaryKey": false, 365 365 + "notNull": true, 366 366 + "autoincrement": false 367 367 + }, 368 368 + "published": { 369 369 + "name": "published", 370 370 + "type": "integer", 371 371 + "primaryKey": false, 372 372 + "notNull": false, 373 373 + "autoincrement": false, 374 374 + "default": false 375 375 + }, 376 376 + "password": { 377 377 + "name": "password", 378 378 + "type": "text(256)", 379 379 + "primaryKey": false, 380 380 + "notNull": false, 381 381 + "autoincrement": false 382 382 + }, 383 383 + "password_protected": { 384 384 + "name": "password_protected", 385 385 + "type": "integer", 386 386 + "primaryKey": false, 387 387 + "notNull": false, 388 388 + "autoincrement": false, 389 389 + "default": false 390 390 + }, 391 391 + "created_at": { 392 392 + "name": "created_at", 393 393 + "type": "integer", 394 394 + "primaryKey": false, 395 395 + "notNull": false, 396 396 + "autoincrement": false, 397 397 + "default": "(strftime('%s', 'now'))" 398 398 + }, 399 399 + "updated_at": { 400 400 + "name": "updated_at", 401 401 + "type": "integer", 402 402 + "primaryKey": false, 403 403 + "notNull": false, 404 404 + "autoincrement": false, 405 405 + "default": "(strftime('%s', 'now'))" 406 406 + } 407 407 + }, 408 408 + "indexes": { 409 409 + "page_slug_unique": { 410 410 + "name": "page_slug_unique", 411 411 + "columns": [ 412 412 + "slug" 413 413 + ], 414 414 + "isUnique": true 415 415 + } 416 416 + }, 417 417 + "foreignKeys": { 418 418 + "page_workspace_id_workspace_id_fk": { 419 419 + "name": "page_workspace_id_workspace_id_fk", 420 420 + "tableFrom": "page", 421 421 + "tableTo": "workspace", 422 422 + "columnsFrom": [ 423 423 + "workspace_id" 424 424 + ], 425 425 + "columnsTo": [ 426 426 + "id" 427 427 + ], 428 428 + "onDelete": "cascade", 429 429 + "onUpdate": "no action" 430 430 + } 431 431 + }, 432 432 + "compositePrimaryKeys": {}, 433 433 + "uniqueConstraints": {} 434 434 + }, 435 435 + "monitor": { 436 436 + "name": "monitor", 437 437 + "columns": { 438 438 + "id": { 439 439 + "name": "id", 440 440 + "type": "integer", 441 441 + "primaryKey": true, 442 442 + "notNull": true, 443 443 + "autoincrement": false 444 444 + }, 445 445 + "job_type": { 446 446 + "name": "job_type", 447 447 + "type": "text", 448 448 + "primaryKey": false, 449 449 + "notNull": true, 450 450 + "autoincrement": false, 451 451 + "default": "'http'" 452 452 + }, 453 453 + "periodicity": { 454 454 + "name": "periodicity", 455 455 + "type": "text", 456 456 + "primaryKey": false, 457 457 + "notNull": true, 458 458 + "autoincrement": false, 459 459 + "default": "'other'" 460 460 + }, 461 461 + "status": { 462 462 + "name": "status", 463 463 + "type": "text", 464 464 + "primaryKey": false, 465 465 + "notNull": true, 466 466 + "autoincrement": false, 467 467 + "default": "'active'" 468 468 + }, 469 469 + "active": { 470 470 + "name": "active", 471 471 + "type": "integer", 472 472 + "primaryKey": false, 473 473 + "notNull": false, 474 474 + "autoincrement": false, 475 475 + "default": false 476 476 + }, 477 477 + "regions": { 478 478 + "name": "regions", 479 479 + "type": "text", 480 480 + "primaryKey": false, 481 481 + "notNull": true, 482 482 + "autoincrement": false, 483 483 + "default": "''" 484 484 + }, 485 485 + "url": { 486 486 + "name": "url", 487 487 + "type": "text(2048)", 488 488 + "primaryKey": false, 489 489 + "notNull": true, 490 490 + "autoincrement": false 491 491 + }, 492 492 + "name": { 493 493 + "name": "name", 494 494 + "type": "text(256)", 495 495 + "primaryKey": false, 496 496 + "notNull": true, 497 497 + "autoincrement": false, 498 498 + "default": "''" 499 499 + }, 500 500 + "description": { 501 501 + "name": "description", 502 502 + "type": "text", 503 503 + "primaryKey": false, 504 504 + "notNull": true, 505 505 + "autoincrement": false, 506 506 + "default": "''" 507 507 + }, 508 508 + "headers": { 509 509 + "name": "headers", 510 510 + "type": "text", 511 511 + "primaryKey": false, 512 512 + "notNull": false, 513 513 + "autoincrement": false, 514 514 + "default": "''" 515 515 + }, 516 516 + "body": { 517 517 + "name": "body", 518 518 + "type": "text", 519 519 + "primaryKey": false, 520 520 + "notNull": false, 521 521 + "autoincrement": false, 522 522 + "default": "''" 523 523 + }, 524 524 + "method": { 525 525 + "name": "method", 526 526 + "type": "text", 527 527 + "primaryKey": false, 528 528 + "notNull": false, 529 529 + "autoincrement": false, 530 530 + "default": "'GET'" 531 531 + }, 532 532 + "workspace_id": { 533 533 + "name": "workspace_id", 534 534 + "type": "integer", 535 535 + "primaryKey": false, 536 536 + "notNull": false, 537 537 + "autoincrement": false 538 538 + }, 539 539 + "timeout": { 540 540 + "name": "timeout", 541 541 + "type": "integer", 542 542 + "primaryKey": false, 543 543 + "notNull": true, 544 544 + "autoincrement": false, 545 545 + "default": 45000 546 546 + }, 547 547 + "degraded_after": { 548 548 + "name": "degraded_after", 549 549 + "type": "integer", 550 550 + "primaryKey": false, 551 551 + "notNull": false, 552 552 + "autoincrement": false 553 553 + }, 554 554 + "assertions": { 555 555 + "name": "assertions", 556 556 + "type": "text", 557 557 + "primaryKey": false, 558 558 + "notNull": false, 559 559 + "autoincrement": false 560 560 + }, 561 561 + "public": { 562 562 + "name": "public", 563 563 + "type": "integer", 564 564 + "primaryKey": false, 565 565 + "notNull": false, 566 566 + "autoincrement": false, 567 567 + "default": false 568 568 + }, 569 569 + "created_at": { 570 570 + "name": "created_at", 571 571 + "type": "integer", 572 572 + "primaryKey": false, 573 573 + "notNull": false, 574 574 + "autoincrement": false, 575 575 + "default": "(strftime('%s', 'now'))" 576 576 + }, 577 577 + "updated_at": { 578 578 + "name": "updated_at", 579 579 + "type": "integer", 580 580 + "primaryKey": false, 581 581 + "notNull": false, 582 582 + "autoincrement": false, 583 583 + "default": "(strftime('%s', 'now'))" 584 584 + }, 585 585 + "deleted_at": { 586 586 + "name": "deleted_at", 587 587 + "type": "integer", 588 588 + "primaryKey": false, 589 589 + "notNull": false, 590 590 + "autoincrement": false 591 591 + } 592 592 + }, 593 593 + "indexes": {}, 594 594 + "foreignKeys": { 595 595 + "monitor_workspace_id_workspace_id_fk": { 596 596 + "name": "monitor_workspace_id_workspace_id_fk", 597 597 + "tableFrom": "monitor", 598 598 + "tableTo": "workspace", 599 599 + "columnsFrom": [ 600 600 + "workspace_id" 601 601 + ], 602 602 + "columnsTo": [ 603 603 + "id" 604 604 + ], 605 605 + "onDelete": "no action", 606 606 + "onUpdate": "no action" 607 607 + } 608 608 + }, 609 609 + "compositePrimaryKeys": {}, 610 610 + "uniqueConstraints": {} 611 611 + }, 612 612 + "monitors_to_pages": { 613 613 + "name": "monitors_to_pages", 614 614 + "columns": { 615 615 + "monitor_id": { 616 616 + "name": "monitor_id", 617 617 + "type": "integer", 618 618 + "primaryKey": false, 619 619 + "notNull": true, 620 620 + "autoincrement": false 621 621 + }, 622 622 + "page_id": { 623 623 + "name": "page_id", 624 624 + "type": "integer", 625 625 + "primaryKey": false, 626 626 + "notNull": true, 627 627 + "autoincrement": false 628 628 + }, 629 629 + "created_at": { 630 630 + "name": "created_at", 631 631 + "type": "integer", 632 632 + "primaryKey": false, 633 633 + "notNull": false, 634 634 + "autoincrement": false, 635 635 + "default": "(strftime('%s', 'now'))" 636 636 + }, 637 637 + "order": { 638 638 + "name": "order", 639 639 + "type": "integer", 640 640 + "primaryKey": false, 641 641 + "notNull": false, 642 642 + "autoincrement": false, 643 643 + "default": 0 644 644 + } 645 645 + }, 646 646 + "indexes": {}, 647 647 + "foreignKeys": { 648 648 + "monitors_to_pages_monitor_id_monitor_id_fk": { 649 649 + "name": "monitors_to_pages_monitor_id_monitor_id_fk", 650 650 + "tableFrom": "monitors_to_pages", 651 651 + "tableTo": "monitor", 652 652 + "columnsFrom": [ 653 653 + "monitor_id" 654 654 + ], 655 655 + "columnsTo": [ 656 656 + "id" 657 657 + ], 658 658 + "onDelete": "cascade", 659 659 + "onUpdate": "no action" 660 660 + }, 661 661 + "monitors_to_pages_page_id_page_id_fk": { 662 662 + "name": "monitors_to_pages_page_id_page_id_fk", 663 663 + "tableFrom": "monitors_to_pages", 664 664 + "tableTo": "page", 665 665 + "columnsFrom": [ 666 666 + "page_id" 667 667 + ], 668 668 + "columnsTo": [ 669 669 + "id" 670 670 + ], 671 671 + "onDelete": "cascade", 672 672 + "onUpdate": "no action" 673 673 + } 674 674 + }, 675 675 + "compositePrimaryKeys": { 676 676 + "monitors_to_pages_monitor_id_page_id_pk": { 677 677 + "columns": [ 678 678 + "monitor_id", 679 679 + "page_id" 680 680 + ], 681 681 + "name": "monitors_to_pages_monitor_id_page_id_pk" 682 682 + } 683 683 + }, 684 684 + "uniqueConstraints": {} 685 685 + }, 686 686 + "workspace": { 687 687 + "name": "workspace", 688 688 + "columns": { 689 689 + "id": { 690 690 + "name": "id", 691 691 + "type": "integer", 692 692 + "primaryKey": true, 693 693 + "notNull": true, 694 694 + "autoincrement": false 695 695 + }, 696 696 + "slug": { 697 697 + "name": "slug", 698 698 + "type": "text", 699 699 + "primaryKey": false, 700 700 + "notNull": true, 701 701 + "autoincrement": false 702 702 + }, 703 703 + "name": { 704 704 + "name": "name", 705 705 + "type": "text", 706 706 + "primaryKey": false, 707 707 + "notNull": false, 708 708 + "autoincrement": false 709 709 + }, 710 710 + "stripe_id": { 711 711 + "name": "stripe_id", 712 712 + "type": "text(256)", 713 713 + "primaryKey": false, 714 714 + "notNull": false, 715 715 + "autoincrement": false 716 716 + }, 717 717 + "subscription_id": { 718 718 + "name": "subscription_id", 719 719 + "type": "text", 720 720 + "primaryKey": false, 721 721 + "notNull": false, 722 722 + "autoincrement": false 723 723 + }, 724 724 + "plan": { 725 725 + "name": "plan", 726 726 + "type": "text", 727 727 + "primaryKey": false, 728 728 + "notNull": false, 729 729 + "autoincrement": false 730 730 + }, 731 731 + "ends_at": { 732 732 + "name": "ends_at", 733 733 + "type": "integer", 734 734 + "primaryKey": false, 735 735 + "notNull": false, 736 736 + "autoincrement": false 737 737 + }, 738 738 + "paid_until": { 739 739 + "name": "paid_until", 740 740 + "type": "integer", 741 741 + "primaryKey": false, 742 742 + "notNull": false, 743 743 + "autoincrement": false 744 744 + }, 745 745 + "limits": { 746 746 + "name": "limits", 747 747 + "type": "text", 748 748 + "primaryKey": false, 749 749 + "notNull": true, 750 750 + "autoincrement": false, 751 751 + "default": "'{}'" 752 752 + }, 753 753 + "created_at": { 754 754 + "name": "created_at", 755 755 + "type": "integer", 756 756 + "primaryKey": false, 757 757 + "notNull": false, 758 758 + "autoincrement": false, 759 759 + "default": "(strftime('%s', 'now'))" 760 760 + }, 761 761 + "updated_at": { 762 762 + "name": "updated_at", 763 763 + "type": "integer", 764 764 + "primaryKey": false, 765 765 + "notNull": false, 766 766 + "autoincrement": false, 767 767 + "default": "(strftime('%s', 'now'))" 768 768 + }, 769 769 + "dsn": { 770 770 + "name": "dsn", 771 771 + "type": "text", 772 772 + "primaryKey": false, 773 773 + "notNull": false, 774 774 + "autoincrement": false 775 775 + } 776 776 + }, 777 777 + "indexes": { 778 778 + "workspace_slug_unique": { 779 779 + "name": "workspace_slug_unique", 780 780 + "columns": [ 781 781 + "slug" 782 782 + ], 783 783 + "isUnique": true 784 784 + }, 785 785 + "workspace_stripe_id_unique": { 786 786 + "name": "workspace_stripe_id_unique", 787 787 + "columns": [ 788 788 + "stripe_id" 789 789 + ], 790 790 + "isUnique": true 791 791 + }, 792 792 + "workspace_id_dsn_unique": { 793 793 + "name": "workspace_id_dsn_unique", 794 794 + "columns": [ 795 795 + "id", 796 796 + "dsn" 797 797 + ], 798 798 + "isUnique": true 799 799 + } 800 800 + }, 801 801 + "foreignKeys": {}, 802 802 + "compositePrimaryKeys": {}, 803 803 + "uniqueConstraints": {} 804 804 + }, 805 805 + "account": { 806 806 + "name": "account", 807 807 + "columns": { 808 808 + "user_id": { 809 809 + "name": "user_id", 810 810 + "type": "integer", 811 811 + "primaryKey": false, 812 812 + "notNull": true, 813 813 + "autoincrement": false 814 814 + }, 815 815 + "type": { 816 816 + "name": "type", 817 817 + "type": "text", 818 818 + "primaryKey": false, 819 819 + "notNull": true, 820 820 + "autoincrement": false 821 821 + }, 822 822 + "provider": { 823 823 + "name": "provider", 824 824 + "type": "text", 825 825 + "primaryKey": false, 826 826 + "notNull": true, 827 827 + "autoincrement": false 828 828 + }, 829 829 + "provider_account_id": { 830 830 + "name": "provider_account_id", 831 831 + "type": "text", 832 832 + "primaryKey": false, 833 833 + "notNull": true, 834 834 + "autoincrement": false 835 835 + }, 836 836 + "refresh_token": { 837 837 + "name": "refresh_token", 838 838 + "type": "text", 839 839 + "primaryKey": false, 840 840 + "notNull": false, 841 841 + "autoincrement": false 842 842 + }, 843 843 + "access_token": { 844 844 + "name": "access_token", 845 845 + "type": "text", 846 846 + "primaryKey": false, 847 847 + "notNull": false, 848 848 + "autoincrement": false 849 849 + }, 850 850 + "expires_at": { 851 851 + "name": "expires_at", 852 852 + "type": "integer", 853 853 + "primaryKey": false, 854 854 + "notNull": false, 855 855 + "autoincrement": false 856 856 + }, 857 857 + "token_type": { 858 858 + "name": "token_type", 859 859 + "type": "text", 860 860 + "primaryKey": false, 861 861 + "notNull": false, 862 862 + "autoincrement": false 863 863 + }, 864 864 + "scope": { 865 865 + "name": "scope", 866 866 + "type": "text", 867 867 + "primaryKey": false, 868 868 + "notNull": false, 869 869 + "autoincrement": false 870 870 + }, 871 871 + "id_token": { 872 872 + "name": "id_token", 873 873 + "type": "text", 874 874 + "primaryKey": false, 875 875 + "notNull": false, 876 876 + "autoincrement": false 877 877 + }, 878 878 + "session_state": { 879 879 + "name": "session_state", 880 880 + "type": "text", 881 881 + "primaryKey": false, 882 882 + "notNull": false, 883 883 + "autoincrement": false 884 884 + } 885 885 + }, 886 886 + "indexes": {}, 887 887 + "foreignKeys": { 888 888 + "account_user_id_user_id_fk": { 889 889 + "name": "account_user_id_user_id_fk", 890 890 + "tableFrom": "account", 891 891 + "tableTo": "user", 892 892 + "columnsFrom": [ 893 893 + "user_id" 894 894 + ], 895 895 + "columnsTo": [ 896 896 + "id" 897 897 + ], 898 898 + "onDelete": "cascade", 899 899 + "onUpdate": "no action" 900 900 + } 901 901 + }, 902 902 + "compositePrimaryKeys": { 903 903 + "account_provider_provider_account_id_pk": { 904 904 + "columns": [ 905 905 + "provider", 906 906 + "provider_account_id" 907 907 + ], 908 908 + "name": "account_provider_provider_account_id_pk" 909 909 + } 910 910 + }, 911 911 + "uniqueConstraints": {} 912 912 + }, 913 913 + "session": { 914 914 + "name": "session", 915 915 + "columns": { 916 916 + "session_token": { 917 917 + "name": "session_token", 918 918 + "type": "text", 919 919 + "primaryKey": true, 920 920 + "notNull": true, 921 921 + "autoincrement": false 922 922 + }, 923 923 + "user_id": { 924 924 + "name": "user_id", 925 925 + "type": "integer", 926 926 + "primaryKey": false, 927 927 + "notNull": true, 928 928 + "autoincrement": false 929 929 + }, 930 930 + "expires": { 931 931 + "name": "expires", 932 932 + "type": "integer", 933 933 + "primaryKey": false, 934 934 + "notNull": true, 935 935 + "autoincrement": false 936 936 + } 937 937 + }, 938 938 + "indexes": {}, 939 939 + "foreignKeys": { 940 940 + "session_user_id_user_id_fk": { 941 941 + "name": "session_user_id_user_id_fk", 942 942 + "tableFrom": "session", 943 943 + "tableTo": "user", 944 944 + "columnsFrom": [ 945 945 + "user_id" 946 946 + ], 947 947 + "columnsTo": [ 948 948 + "id" 949 949 + ], 950 950 + "onDelete": "cascade", 951 951 + "onUpdate": "no action" 952 952 + } 953 953 + }, 954 954 + "compositePrimaryKeys": {}, 955 955 + "uniqueConstraints": {} 956 956 + }, 957 957 + "user": { 958 958 + "name": "user", 959 959 + "columns": { 960 960 + "id": { 961 961 + "name": "id", 962 962 + "type": "integer", 963 963 + "primaryKey": true, 964 964 + "notNull": true, 965 965 + "autoincrement": false 966 966 + }, 967 967 + "tenant_id": { 968 968 + "name": "tenant_id", 969 969 + "type": "text(256)", 970 970 + "primaryKey": false, 971 971 + "notNull": false, 972 972 + "autoincrement": false 973 973 + }, 974 974 + "first_name": { 975 975 + "name": "first_name", 976 976 + "type": "text", 977 977 + "primaryKey": false, 978 978 + "notNull": false, 979 979 + "autoincrement": false, 980 980 + "default": "''" 981 981 + }, 982 982 + "last_name": { 983 983 + "name": "last_name", 984 984 + "type": "text", 985 985 + "primaryKey": false, 986 986 + "notNull": false, 987 987 + "autoincrement": false, 988 988 + "default": "''" 989 989 + }, 990 990 + "photo_url": { 991 991 + "name": "photo_url", 992 992 + "type": "text", 993 993 + "primaryKey": false, 994 994 + "notNull": false, 995 995 + "autoincrement": false, 996 996 + "default": "''" 997 997 + }, 998 998 + "name": { 999 999 + "name": "name", 1000 1000 + "type": "text", 1001 1001 + "primaryKey": false, 1002 1002 + "notNull": false, 1003 1003 + "autoincrement": false 1004 1004 + }, 1005 1005 + "email": { 1006 1006 + "name": "email", 1007 1007 + "type": "text", 1008 1008 + "primaryKey": false, 1009 1009 + "notNull": false, 1010 1010 + "autoincrement": false, 1011 1011 + "default": "''" 1012 1012 + }, 1013 1013 + "emailVerified": { 1014 1014 + "name": "emailVerified", 1015 1015 + "type": "integer", 1016 1016 + "primaryKey": false, 1017 1017 + "notNull": false, 1018 1018 + "autoincrement": false 1019 1019 + }, 1020 1020 + "created_at": { 1021 1021 + "name": "created_at", 1022 1022 + "type": "integer", 1023 1023 + "primaryKey": false, 1024 1024 + "notNull": false, 1025 1025 + "autoincrement": false, 1026 1026 + "default": "(strftime('%s', 'now'))" 1027 1027 + }, 1028 1028 + "updated_at": { 1029 1029 + "name": "updated_at", 1030 1030 + "type": "integer", 1031 1031 + "primaryKey": false, 1032 1032 + "notNull": false, 1033 1033 + "autoincrement": false, 1034 1034 + "default": "(strftime('%s', 'now'))" 1035 1035 + } 1036 1036 + }, 1037 1037 + "indexes": { 1038 1038 + "user_tenant_id_unique": { 1039 1039 + "name": "user_tenant_id_unique", 1040 1040 + "columns": [ 1041 1041 + "tenant_id" 1042 1042 + ], 1043 1043 + "isUnique": true 1044 1044 + } 1045 1045 + }, 1046 1046 + "foreignKeys": {}, 1047 1047 + "compositePrimaryKeys": {}, 1048 1048 + "uniqueConstraints": {} 1049 1049 + }, 1050 1050 + "users_to_workspaces": { 1051 1051 + "name": "users_to_workspaces", 1052 1052 + "columns": { 1053 1053 + "user_id": { 1054 1054 + "name": "user_id", 1055 1055 + "type": "integer", 1056 1056 + "primaryKey": false, 1057 1057 + "notNull": true, 1058 1058 + "autoincrement": false 1059 1059 + }, 1060 1060 + "workspace_id": { 1061 1061 + "name": "workspace_id", 1062 1062 + "type": "integer", 1063 1063 + "primaryKey": false, 1064 1064 + "notNull": true, 1065 1065 + "autoincrement": false 1066 1066 + }, 1067 1067 + "role": { 1068 1068 + "name": "role", 1069 1069 + "type": "text", 1070 1070 + "primaryKey": false, 1071 1071 + "notNull": true, 1072 1072 + "autoincrement": false, 1073 1073 + "default": "'member'" 1074 1074 + }, 1075 1075 + "created_at": { 1076 1076 + "name": "created_at", 1077 1077 + "type": "integer", 1078 1078 + "primaryKey": false, 1079 1079 + "notNull": false, 1080 1080 + "autoincrement": false, 1081 1081 + "default": "(strftime('%s', 'now'))" 1082 1082 + } 1083 1083 + }, 1084 1084 + "indexes": {}, 1085 1085 + "foreignKeys": { 1086 1086 + "users_to_workspaces_user_id_user_id_fk": { 1087 1087 + "name": "users_to_workspaces_user_id_user_id_fk", 1088 1088 + "tableFrom": "users_to_workspaces", 1089 1089 + "tableTo": "user", 1090 1090 + "columnsFrom": [ 1091 1091 + "user_id" 1092 1092 + ], 1093 1093 + "columnsTo": [ 1094 1094 + "id" 1095 1095 + ], 1096 1096 + "onDelete": "no action", 1097 1097 + "onUpdate": "no action" 1098 1098 + }, 1099 1099 + "users_to_workspaces_workspace_id_workspace_id_fk": { 1100 1100 + "name": "users_to_workspaces_workspace_id_workspace_id_fk", 1101 1101 + "tableFrom": "users_to_workspaces", 1102 1102 + "tableTo": "workspace", 1103 1103 + "columnsFrom": [ 1104 1104 + "workspace_id" 1105 1105 + ], 1106 1106 + "columnsTo": [ 1107 1107 + "id" 1108 1108 + ], 1109 1109 + "onDelete": "no action", 1110 1110 + "onUpdate": "no action" 1111 1111 + } 1112 1112 + }, 1113 1113 + "compositePrimaryKeys": { 1114 1114 + "users_to_workspaces_user_id_workspace_id_pk": { 1115 1115 + "columns": [ 1116 1116 + "user_id", 1117 1117 + "workspace_id" 1118 1118 + ], 1119 1119 + "name": "users_to_workspaces_user_id_workspace_id_pk" 1120 1120 + } 1121 1121 + }, 1122 1122 + "uniqueConstraints": {} 1123 1123 + }, 1124 1124 + "verification_token": { 1125 1125 + "name": "verification_token", 1126 1126 + "columns": { 1127 1127 + "identifier": { 1128 1128 + "name": "identifier", 1129 1129 + "type": "text", 1130 1130 + "primaryKey": false, 1131 1131 + "notNull": true, 1132 1132 + "autoincrement": false 1133 1133 + }, 1134 1134 + "token": { 1135 1135 + "name": "token", 1136 1136 + "type": "text", 1137 1137 + "primaryKey": false, 1138 1138 + "notNull": true, 1139 1139 + "autoincrement": false 1140 1140 + }, 1141 1141 + "expires": { 1142 1142 + "name": "expires", 1143 1143 + "type": "integer", 1144 1144 + "primaryKey": false, 1145 1145 + "notNull": true, 1146 1146 + "autoincrement": false 1147 1147 + } 1148 1148 + }, 1149 1149 + "indexes": {}, 1150 1150 + "foreignKeys": {}, 1151 1151 + "compositePrimaryKeys": { 1152 1152 + "verification_token_identifier_token_pk": { 1153 1153 + "columns": [ 1154 1154 + "identifier", 1155 1155 + "token" 1156 1156 + ], 1157 1157 + "name": "verification_token_identifier_token_pk" 1158 1158 + } 1159 1159 + }, 1160 1160 + "uniqueConstraints": {} 1161 1161 + }, 1162 1162 + "page_subscriber": { 1163 1163 + "name": "page_subscriber", 1164 1164 + "columns": { 1165 1165 + "id": { 1166 1166 + "name": "id", 1167 1167 + "type": "integer", 1168 1168 + "primaryKey": true, 1169 1169 + "notNull": true, 1170 1170 + "autoincrement": false 1171 1171 + }, 1172 1172 + "email": { 1173 1173 + "name": "email", 1174 1174 + "type": "text", 1175 1175 + "primaryKey": false, 1176 1176 + "notNull": true, 1177 1177 + "autoincrement": false 1178 1178 + }, 1179 1179 + "page_id": { 1180 1180 + "name": "page_id", 1181 1181 + "type": "integer", 1182 1182 + "primaryKey": false, 1183 1183 + "notNull": true, 1184 1184 + "autoincrement": false 1185 1185 + }, 1186 1186 + "token": { 1187 1187 + "name": "token", 1188 1188 + "type": "text", 1189 1189 + "primaryKey": false, 1190 1190 + "notNull": false, 1191 1191 + "autoincrement": false 1192 1192 + }, 1193 1193 + "accepted_at": { 1194 1194 + "name": "accepted_at", 1195 1195 + "type": "integer", 1196 1196 + "primaryKey": false, 1197 1197 + "notNull": false, 1198 1198 + "autoincrement": false 1199 1199 + }, 1200 1200 + "expires_at": { 1201 1201 + "name": "expires_at", 1202 1202 + "type": "integer", 1203 1203 + "primaryKey": false, 1204 1204 + "notNull": false, 1205 1205 + "autoincrement": false 1206 1206 + }, 1207 1207 + "created_at": { 1208 1208 + "name": "created_at", 1209 1209 + "type": "integer", 1210 1210 + "primaryKey": false, 1211 1211 + "notNull": false, 1212 1212 + "autoincrement": false, 1213 1213 + "default": "(strftime('%s', 'now'))" 1214 1214 + }, 1215 1215 + "updated_at": { 1216 1216 + "name": "updated_at", 1217 1217 + "type": "integer", 1218 1218 + "primaryKey": false, 1219 1219 + "notNull": false, 1220 1220 + "autoincrement": false, 1221 1221 + "default": "(strftime('%s', 'now'))" 1222 1222 + } 1223 1223 + }, 1224 1224 + "indexes": {}, 1225 1225 + "foreignKeys": { 1226 1226 + "page_subscriber_page_id_page_id_fk": { 1227 1227 + "name": "page_subscriber_page_id_page_id_fk", 1228 1228 + "tableFrom": "page_subscriber", 1229 1229 + "tableTo": "page", 1230 1230 + "columnsFrom": [ 1231 1231 + "page_id" 1232 1232 + ], 1233 1233 + "columnsTo": [ 1234 1234 + "id" 1235 1235 + ], 1236 1236 + "onDelete": "no action", 1237 1237 + "onUpdate": "no action" 1238 1238 + } 1239 1239 + }, 1240 1240 + "compositePrimaryKeys": {}, 1241 1241 + "uniqueConstraints": {} 1242 1242 + }, 1243 1243 + "notification": { 1244 1244 + "name": "notification", 1245 1245 + "columns": { 1246 1246 + "id": { 1247 1247 + "name": "id", 1248 1248 + "type": "integer", 1249 1249 + "primaryKey": true, 1250 1250 + "notNull": true, 1251 1251 + "autoincrement": false 1252 1252 + }, 1253 1253 + "name": { 1254 1254 + "name": "name", 1255 1255 + "type": "text", 1256 1256 + "primaryKey": false, 1257 1257 + "notNull": true, 1258 1258 + "autoincrement": false 1259 1259 + }, 1260 1260 + "provider": { 1261 1261 + "name": "provider", 1262 1262 + "type": "text", 1263 1263 + "primaryKey": false, 1264 1264 + "notNull": true, 1265 1265 + "autoincrement": false 1266 1266 + }, 1267 1267 + "data": { 1268 1268 + "name": "data", 1269 1269 + "type": "text", 1270 1270 + "primaryKey": false, 1271 1271 + "notNull": false, 1272 1272 + "autoincrement": false, 1273 1273 + "default": "'{}'" 1274 1274 + }, 1275 1275 + "workspace_id": { 1276 1276 + "name": "workspace_id", 1277 1277 + "type": "integer", 1278 1278 + "primaryKey": false, 1279 1279 + "notNull": false, 1280 1280 + "autoincrement": false 1281 1281 + }, 1282 1282 + "created_at": { 1283 1283 + "name": "created_at", 1284 1284 + "type": "integer", 1285 1285 + "primaryKey": false, 1286 1286 + "notNull": false, 1287 1287 + "autoincrement": false, 1288 1288 + "default": "(strftime('%s', 'now'))" 1289 1289 + }, 1290 1290 + "updated_at": { 1291 1291 + "name": "updated_at", 1292 1292 + "type": "integer", 1293 1293 + "primaryKey": false, 1294 1294 + "notNull": false, 1295 1295 + "autoincrement": false, 1296 1296 + "default": "(strftime('%s', 'now'))" 1297 1297 + } 1298 1298 + }, 1299 1299 + "indexes": {}, 1300 1300 + "foreignKeys": { 1301 1301 + "notification_workspace_id_workspace_id_fk": { 1302 1302 + "name": "notification_workspace_id_workspace_id_fk", 1303 1303 + "tableFrom": "notification", 1304 1304 + "tableTo": "workspace", 1305 1305 + "columnsFrom": [ 1306 1306 + "workspace_id" 1307 1307 + ], 1308 1308 + "columnsTo": [ 1309 1309 + "id" 1310 1310 + ], 1311 1311 + "onDelete": "no action", 1312 1312 + "onUpdate": "no action" 1313 1313 + } 1314 1314 + }, 1315 1315 + "compositePrimaryKeys": {}, 1316 1316 + "uniqueConstraints": {} 1317 1317 + }, 1318 1318 + "notifications_to_monitors": { 1319 1319 + "name": "notifications_to_monitors", 1320 1320 + "columns": { 1321 1321 + "monitor_id": { 1322 1322 + "name": "monitor_id", 1323 1323 + "type": "integer", 1324 1324 + "primaryKey": false, 1325 1325 + "notNull": true, 1326 1326 + "autoincrement": false 1327 1327 + }, 1328 1328 + "notification_id": { 1329 1329 + "name": "notification_id", 1330 1330 + "type": "integer", 1331 1331 + "primaryKey": false, 1332 1332 + "notNull": true, 1333 1333 + "autoincrement": false 1334 1334 + }, 1335 1335 + "created_at": { 1336 1336 + "name": "created_at", 1337 1337 + "type": "integer", 1338 1338 + "primaryKey": false, 1339 1339 + "notNull": false, 1340 1340 + "autoincrement": false, 1341 1341 + "default": "(strftime('%s', 'now'))" 1342 1342 + } 1343 1343 + }, 1344 1344 + "indexes": {}, 1345 1345 + "foreignKeys": { 1346 1346 + "notifications_to_monitors_monitor_id_monitor_id_fk": { 1347 1347 + "name": "notifications_to_monitors_monitor_id_monitor_id_fk", 1348 1348 + "tableFrom": "notifications_to_monitors", 1349 1349 + "tableTo": "monitor", 1350 1350 + "columnsFrom": [ 1351 1351 + "monitor_id" 1352 1352 + ], 1353 1353 + "columnsTo": [ 1354 1354 + "id" 1355 1355 + ], 1356 1356 + "onDelete": "cascade", 1357 1357 + "onUpdate": "no action" 1358 1358 + }, 1359 1359 + "notifications_to_monitors_notification_id_notification_id_fk": { 1360 1360 + "name": "notifications_to_monitors_notification_id_notification_id_fk", 1361 1361 + "tableFrom": "notifications_to_monitors", 1362 1362 + "tableTo": "notification", 1363 1363 + "columnsFrom": [ 1364 1364 + "notification_id" 1365 1365 + ], 1366 1366 + "columnsTo": [ 1367 1367 + "id" 1368 1368 + ], 1369 1369 + "onDelete": "cascade", 1370 1370 + "onUpdate": "no action" 1371 1371 + } 1372 1372 + }, 1373 1373 + "compositePrimaryKeys": { 1374 1374 + "notifications_to_monitors_monitor_id_notification_id_pk": { 1375 1375 + "columns": [ 1376 1376 + "monitor_id", 1377 1377 + "notification_id" 1378 1378 + ], 1379 1379 + "name": "notifications_to_monitors_monitor_id_notification_id_pk" 1380 1380 + } 1381 1381 + }, 1382 1382 + "uniqueConstraints": {} 1383 1383 + }, 1384 1384 + "monitor_status": { 1385 1385 + "name": "monitor_status", 1386 1386 + "columns": { 1387 1387 + "monitor_id": { 1388 1388 + "name": "monitor_id", 1389 1389 + "type": "integer", 1390 1390 + "primaryKey": false, 1391 1391 + "notNull": true, 1392 1392 + "autoincrement": false 1393 1393 + }, 1394 1394 + "region": { 1395 1395 + "name": "region", 1396 1396 + "type": "text", 1397 1397 + "primaryKey": false, 1398 1398 + "notNull": true, 1399 1399 + "autoincrement": false, 1400 1400 + "default": "''" 1401 1401 + }, 1402 1402 + "status": { 1403 1403 + "name": "status", 1404 1404 + "type": "text", 1405 1405 + "primaryKey": false, 1406 1406 + "notNull": true, 1407 1407 + "autoincrement": false, 1408 1408 + "default": "'active'" 1409 1409 + }, 1410 1410 + "created_at": { 1411 1411 + "name": "created_at", 1412 1412 + "type": "integer", 1413 1413 + "primaryKey": false, 1414 1414 + "notNull": false, 1415 1415 + "autoincrement": false, 1416 1416 + "default": "(strftime('%s', 'now'))" 1417 1417 + }, 1418 1418 + "updated_at": { 1419 1419 + "name": "updated_at", 1420 1420 + "type": "integer", 1421 1421 + "primaryKey": false, 1422 1422 + "notNull": false, 1423 1423 + "autoincrement": false, 1424 1424 + "default": "(strftime('%s', 'now'))" 1425 1425 + } 1426 1426 + }, 1427 1427 + "indexes": { 1428 1428 + "monitor_status_idx": { 1429 1429 + "name": "monitor_status_idx", 1430 1430 + "columns": [ 1431 1431 + "monitor_id", 1432 1432 + "region" 1433 1433 + ], 1434 1434 + "isUnique": false 1435 1435 + } 1436 1436 + }, 1437 1437 + "foreignKeys": { 1438 1438 + "monitor_status_monitor_id_monitor_id_fk": { 1439 1439 + "name": "monitor_status_monitor_id_monitor_id_fk", 1440 1440 + "tableFrom": "monitor_status", 1441 1441 + "tableTo": "monitor", 1442 1442 + "columnsFrom": [ 1443 1443 + "monitor_id" 1444 1444 + ], 1445 1445 + "columnsTo": [ 1446 1446 + "id" 1447 1447 + ], 1448 1448 + "onDelete": "cascade", 1449 1449 + "onUpdate": "no action" 1450 1450 + } 1451 1451 + }, 1452 1452 + "compositePrimaryKeys": { 1453 1453 + "monitor_status_monitor_id_region_pk": { 1454 1454 + "columns": [ 1455 1455 + "monitor_id", 1456 1456 + "region" 1457 1457 + ], 1458 1458 + "name": "monitor_status_monitor_id_region_pk" 1459 1459 + } 1460 1460 + }, 1461 1461 + "uniqueConstraints": {} 1462 1462 + }, 1463 1463 + "invitation": { 1464 1464 + "name": "invitation", 1465 1465 + "columns": { 1466 1466 + "id": { 1467 1467 + "name": "id", 1468 1468 + "type": "integer", 1469 1469 + "primaryKey": true, 1470 1470 + "notNull": true, 1471 1471 + "autoincrement": false 1472 1472 + }, 1473 1473 + "email": { 1474 1474 + "name": "email", 1475 1475 + "type": "text", 1476 1476 + "primaryKey": false, 1477 1477 + "notNull": true, 1478 1478 + "autoincrement": false 1479 1479 + }, 1480 1480 + "role": { 1481 1481 + "name": "role", 1482 1482 + "type": "text", 1483 1483 + "primaryKey": false, 1484 1484 + "notNull": true, 1485 1485 + "autoincrement": false, 1486 1486 + "default": "'member'" 1487 1487 + }, 1488 1488 + "workspace_id": { 1489 1489 + "name": "workspace_id", 1490 1490 + "type": "integer", 1491 1491 + "primaryKey": false, 1492 1492 + "notNull": true, 1493 1493 + "autoincrement": false 1494 1494 + }, 1495 1495 + "token": { 1496 1496 + "name": "token", 1497 1497 + "type": "text", 1498 1498 + "primaryKey": false, 1499 1499 + "notNull": true, 1500 1500 + "autoincrement": false 1501 1501 + }, 1502 1502 + "expires_at": { 1503 1503 + "name": "expires_at", 1504 1504 + "type": "integer", 1505 1505 + "primaryKey": false, 1506 1506 + "notNull": true, 1507 1507 + "autoincrement": false 1508 1508 + }, 1509 1509 + "created_at": { 1510 1510 + "name": "created_at", 1511 1511 + "type": "integer", 1512 1512 + "primaryKey": false, 1513 1513 + "notNull": false, 1514 1514 + "autoincrement": false, 1515 1515 + "default": "(strftime('%s', 'now'))" 1516 1516 + }, 1517 1517 + "accepted_at": { 1518 1518 + "name": "accepted_at", 1519 1519 + "type": "integer", 1520 1520 + "primaryKey": false, 1521 1521 + "notNull": false, 1522 1522 + "autoincrement": false 1523 1523 + } 1524 1524 + }, 1525 1525 + "indexes": {}, 1526 1526 + "foreignKeys": {}, 1527 1527 + "compositePrimaryKeys": {}, 1528 1528 + "uniqueConstraints": {} 1529 1529 + }, 1530 1530 + "incident": { 1531 1531 + "name": "incident", 1532 1532 + "columns": { 1533 1533 + "id": { 1534 1534 + "name": "id", 1535 1535 + "type": "integer", 1536 1536 + "primaryKey": true, 1537 1537 + "notNull": true, 1538 1538 + "autoincrement": false 1539 1539 + }, 1540 1540 + "title": { 1541 1541 + "name": "title", 1542 1542 + "type": "text", 1543 1543 + "primaryKey": false, 1544 1544 + "notNull": true, 1545 1545 + "autoincrement": false, 1546 1546 + "default": "''" 1547 1547 + }, 1548 1548 + "summary": { 1549 1549 + "name": "summary", 1550 1550 + "type": "text", 1551 1551 + "primaryKey": false, 1552 1552 + "notNull": true, 1553 1553 + "autoincrement": false, 1554 1554 + "default": "''" 1555 1555 + }, 1556 1556 + "status": { 1557 1557 + "name": "status", 1558 1558 + "type": "text", 1559 1559 + "primaryKey": false, 1560 1560 + "notNull": true, 1561 1561 + "autoincrement": false, 1562 1562 + "default": "'triage'" 1563 1563 + }, 1564 1564 + "monitor_id": { 1565 1565 + "name": "monitor_id", 1566 1566 + "type": "integer", 1567 1567 + "primaryKey": false, 1568 1568 + "notNull": false, 1569 1569 + "autoincrement": false 1570 1570 + }, 1571 1571 + "workspace_id": { 1572 1572 + "name": "workspace_id", 1573 1573 + "type": "integer", 1574 1574 + "primaryKey": false, 1575 1575 + "notNull": false, 1576 1576 + "autoincrement": false 1577 1577 + }, 1578 1578 + "started_at": { 1579 1579 + "name": "started_at", 1580 1580 + "type": "integer", 1581 1581 + "primaryKey": false, 1582 1582 + "notNull": true, 1583 1583 + "autoincrement": false, 1584 1584 + "default": "(strftime('%s', 'now'))" 1585 1585 + }, 1586 1586 + "acknowledged_at": { 1587 1587 + "name": "acknowledged_at", 1588 1588 + "type": "integer", 1589 1589 + "primaryKey": false, 1590 1590 + "notNull": false, 1591 1591 + "autoincrement": false 1592 1592 + }, 1593 1593 + "acknowledged_by": { 1594 1594 + "name": "acknowledged_by", 1595 1595 + "type": "integer", 1596 1596 + "primaryKey": false, 1597 1597 + "notNull": false, 1598 1598 + "autoincrement": false 1599 1599 + }, 1600 1600 + "resolved_at": { 1601 1601 + "name": "resolved_at", 1602 1602 + "type": "integer", 1603 1603 + "primaryKey": false, 1604 1604 + "notNull": false, 1605 1605 + "autoincrement": false 1606 1606 + }, 1607 1607 + "resolved_by": { 1608 1608 + "name": "resolved_by", 1609 1609 + "type": "integer", 1610 1610 + "primaryKey": false, 1611 1611 + "notNull": false, 1612 1612 + "autoincrement": false 1613 1613 + }, 1614 1614 + "incident_screenshot_url": { 1615 1615 + "name": "incident_screenshot_url", 1616 1616 + "type": "text", 1617 1617 + "primaryKey": false, 1618 1618 + "notNull": false, 1619 1619 + "autoincrement": false 1620 1620 + }, 1621 1621 + "recovery_screenshot_url": { 1622 1622 + "name": "recovery_screenshot_url", 1623 1623 + "type": "text", 1624 1624 + "primaryKey": false, 1625 1625 + "notNull": false, 1626 1626 + "autoincrement": false 1627 1627 + }, 1628 1628 + "auto_resolved": { 1629 1629 + "name": "auto_resolved", 1630 1630 + "type": "integer", 1631 1631 + "primaryKey": false, 1632 1632 + "notNull": false, 1633 1633 + "autoincrement": false, 1634 1634 + "default": false 1635 1635 + }, 1636 1636 + "created_at": { 1637 1637 + "name": "created_at", 1638 1638 + "type": "integer", 1639 1639 + "primaryKey": false, 1640 1640 + "notNull": false, 1641 1641 + "autoincrement": false, 1642 1642 + "default": "(strftime('%s', 'now'))" 1643 1643 + }, 1644 1644 + "updated_at": { 1645 1645 + "name": "updated_at", 1646 1646 + "type": "integer", 1647 1647 + "primaryKey": false, 1648 1648 + "notNull": false, 1649 1649 + "autoincrement": false, 1650 1650 + "default": "(strftime('%s', 'now'))" 1651 1651 + } 1652 1652 + }, 1653 1653 + "indexes": { 1654 1654 + "incident_monitor_id_started_at_unique": { 1655 1655 + "name": "incident_monitor_id_started_at_unique", 1656 1656 + "columns": [ 1657 1657 + "monitor_id", 1658 1658 + "started_at" 1659 1659 + ], 1660 1660 + "isUnique": true 1661 1661 + } 1662 1662 + }, 1663 1663 + "foreignKeys": { 1664 1664 + "incident_monitor_id_monitor_id_fk": { 1665 1665 + "name": "incident_monitor_id_monitor_id_fk", 1666 1666 + "tableFrom": "incident", 1667 1667 + "tableTo": "monitor", 1668 1668 + "columnsFrom": [ 1669 1669 + "monitor_id" 1670 1670 + ], 1671 1671 + "columnsTo": [ 1672 1672 + "id" 1673 1673 + ], 1674 1674 + "onDelete": "set default", 1675 1675 + "onUpdate": "no action" 1676 1676 + }, 1677 1677 + "incident_workspace_id_workspace_id_fk": { 1678 1678 + "name": "incident_workspace_id_workspace_id_fk", 1679 1679 + "tableFrom": "incident", 1680 1680 + "tableTo": "workspace", 1681 1681 + "columnsFrom": [ 1682 1682 + "workspace_id" 1683 1683 + ], 1684 1684 + "columnsTo": [ 1685 1685 + "id" 1686 1686 + ], 1687 1687 + "onDelete": "no action", 1688 1688 + "onUpdate": "no action" 1689 1689 + }, 1690 1690 + "incident_acknowledged_by_user_id_fk": { 1691 1691 + "name": "incident_acknowledged_by_user_id_fk", 1692 1692 + "tableFrom": "incident", 1693 1693 + "tableTo": "user", 1694 1694 + "columnsFrom": [ 1695 1695 + "acknowledged_by" 1696 1696 + ], 1697 1697 + "columnsTo": [ 1698 1698 + "id" 1699 1699 + ], 1700 1700 + "onDelete": "no action", 1701 1701 + "onUpdate": "no action" 1702 1702 + }, 1703 1703 + "incident_resolved_by_user_id_fk": { 1704 1704 + "name": "incident_resolved_by_user_id_fk", 1705 1705 + "tableFrom": "incident", 1706 1706 + "tableTo": "user", 1707 1707 + "columnsFrom": [ 1708 1708 + "resolved_by" 1709 1709 + ], 1710 1710 + "columnsTo": [ 1711 1711 + "id" 1712 1712 + ], 1713 1713 + "onDelete": "no action", 1714 1714 + "onUpdate": "no action" 1715 1715 + } 1716 1716 + }, 1717 1717 + "compositePrimaryKeys": {}, 1718 1718 + "uniqueConstraints": {} 1719 1719 + }, 1720 1720 + "monitor_tag": { 1721 1721 + "name": "monitor_tag", 1722 1722 + "columns": { 1723 1723 + "id": { 1724 1724 + "name": "id", 1725 1725 + "type": "integer", 1726 1726 + "primaryKey": true, 1727 1727 + "notNull": true, 1728 1728 + "autoincrement": false 1729 1729 + }, 1730 1730 + "workspace_id": { 1731 1731 + "name": "workspace_id", 1732 1732 + "type": "integer", 1733 1733 + "primaryKey": false, 1734 1734 + "notNull": true, 1735 1735 + "autoincrement": false 1736 1736 + }, 1737 1737 + "name": { 1738 1738 + "name": "name", 1739 1739 + "type": "text", 1740 1740 + "primaryKey": false, 1741 1741 + "notNull": true, 1742 1742 + "autoincrement": false 1743 1743 + }, 1744 1744 + "color": { 1745 1745 + "name": "color", 1746 1746 + "type": "text", 1747 1747 + "primaryKey": false, 1748 1748 + "notNull": true, 1749 1749 + "autoincrement": false 1750 1750 + }, 1751 1751 + "created_at": { 1752 1752 + "name": "created_at", 1753 1753 + "type": "integer", 1754 1754 + "primaryKey": false, 1755 1755 + "notNull": false, 1756 1756 + "autoincrement": false, 1757 1757 + "default": "(strftime('%s', 'now'))" 1758 1758 + }, 1759 1759 + "updated_at": { 1760 1760 + "name": "updated_at", 1761 1761 + "type": "integer", 1762 1762 + "primaryKey": false, 1763 1763 + "notNull": false, 1764 1764 + "autoincrement": false, 1765 1765 + "default": "(strftime('%s', 'now'))" 1766 1766 + } 1767 1767 + }, 1768 1768 + "indexes": {}, 1769 1769 + "foreignKeys": { 1770 1770 + "monitor_tag_workspace_id_workspace_id_fk": { 1771 1771 + "name": "monitor_tag_workspace_id_workspace_id_fk", 1772 1772 + "tableFrom": "monitor_tag", 1773 1773 + "tableTo": "workspace", 1774 1774 + "columnsFrom": [ 1775 1775 + "workspace_id" 1776 1776 + ], 1777 1777 + "columnsTo": [ 1778 1778 + "id" 1779 1779 + ], 1780 1780 + "onDelete": "cascade", 1781 1781 + "onUpdate": "no action" 1782 1782 + } 1783 1783 + }, 1784 1784 + "compositePrimaryKeys": {}, 1785 1785 + "uniqueConstraints": {} 1786 1786 + }, 1787 1787 + "monitor_tag_to_monitor": { 1788 1788 + "name": "monitor_tag_to_monitor", 1789 1789 + "columns": { 1790 1790 + "monitor_id": { 1791 1791 + "name": "monitor_id", 1792 1792 + "type": "integer", 1793 1793 + "primaryKey": false, 1794 1794 + "notNull": true, 1795 1795 + "autoincrement": false 1796 1796 + }, 1797 1797 + "monitor_tag_id": { 1798 1798 + "name": "monitor_tag_id", 1799 1799 + "type": "integer", 1800 1800 + "primaryKey": false, 1801 1801 + "notNull": true, 1802 1802 + "autoincrement": false 1803 1803 + }, 1804 1804 + "created_at": { 1805 1805 + "name": "created_at", 1806 1806 + "type": "integer", 1807 1807 + "primaryKey": false, 1808 1808 + "notNull": false, 1809 1809 + "autoincrement": false, 1810 1810 + "default": "(strftime('%s', 'now'))" 1811 1811 + } 1812 1812 + }, 1813 1813 + "indexes": {}, 1814 1814 + "foreignKeys": { 1815 1815 + "monitor_tag_to_monitor_monitor_id_monitor_id_fk": { 1816 1816 + "name": "monitor_tag_to_monitor_monitor_id_monitor_id_fk", 1817 1817 + "tableFrom": "monitor_tag_to_monitor", 1818 1818 + "tableTo": "monitor", 1819 1819 + "columnsFrom": [ 1820 1820 + "monitor_id" 1821 1821 + ], 1822 1822 + "columnsTo": [ 1823 1823 + "id" 1824 1824 + ], 1825 1825 + "onDelete": "cascade", 1826 1826 + "onUpdate": "no action" 1827 1827 + }, 1828 1828 + "monitor_tag_to_monitor_monitor_tag_id_monitor_tag_id_fk": { 1829 1829 + "name": "monitor_tag_to_monitor_monitor_tag_id_monitor_tag_id_fk", 1830 1830 + "tableFrom": "monitor_tag_to_monitor", 1831 1831 + "tableTo": "monitor_tag", 1832 1832 + "columnsFrom": [ 1833 1833 + "monitor_tag_id" 1834 1834 + ], 1835 1835 + "columnsTo": [ 1836 1836 + "id" 1837 1837 + ], 1838 1838 + "onDelete": "cascade", 1839 1839 + "onUpdate": "no action" 1840 1840 + } 1841 1841 + }, 1842 1842 + "compositePrimaryKeys": { 1843 1843 + "monitor_tag_to_monitor_monitor_id_monitor_tag_id_pk": { 1844 1844 + "columns": [ 1845 1845 + "monitor_id", 1846 1846 + "monitor_tag_id" 1847 1847 + ], 1848 1848 + "name": "monitor_tag_to_monitor_monitor_id_monitor_tag_id_pk" 1849 1849 + } 1850 1850 + }, 1851 1851 + "uniqueConstraints": {} 1852 1852 + }, 1853 1853 + "application": { 1854 1854 + "name": "application", 1855 1855 + "columns": { 1856 1856 + "id": { 1857 1857 + "name": "id", 1858 1858 + "type": "integer", 1859 1859 + "primaryKey": true, 1860 1860 + "notNull": true, 1861 1861 + "autoincrement": false 1862 1862 + }, 1863 1863 + "name": { 1864 1864 + "name": "name", 1865 1865 + "type": "text", 1866 1866 + "primaryKey": false, 1867 1867 + "notNull": false, 1868 1868 + "autoincrement": false 1869 1869 + }, 1870 1870 + "dsn": { 1871 1871 + "name": "dsn", 1872 1872 + "type": "text", 1873 1873 + "primaryKey": false, 1874 1874 + "notNull": false, 1875 1875 + "autoincrement": false 1876 1876 + }, 1877 1877 + "workspace_id": { 1878 1878 + "name": "workspace_id", 1879 1879 + "type": "integer", 1880 1880 + "primaryKey": false, 1881 1881 + "notNull": false, 1882 1882 + "autoincrement": false 1883 1883 + }, 1884 1884 + "created_at": { 1885 1885 + "name": "created_at", 1886 1886 + "type": "integer", 1887 1887 + "primaryKey": false, 1888 1888 + "notNull": false, 1889 1889 + "autoincrement": false, 1890 1890 + "default": "(strftime('%s', 'now'))" 1891 1891 + }, 1892 1892 + "updated_at": { 1893 1893 + "name": "updated_at", 1894 1894 + "type": "integer", 1895 1895 + "primaryKey": false, 1896 1896 + "notNull": false, 1897 1897 + "autoincrement": false, 1898 1898 + "default": "(strftime('%s', 'now'))" 1899 1899 + } 1900 1900 + }, 1901 1901 + "indexes": { 1902 1902 + "application_dsn_unique": { 1903 1903 + "name": "application_dsn_unique", 1904 1904 + "columns": [ 1905 1905 + "dsn" 1906 1906 + ], 1907 1907 + "isUnique": true 1908 1908 + } 1909 1909 + }, 1910 1910 + "foreignKeys": { 1911 1911 + "application_workspace_id_workspace_id_fk": { 1912 1912 + "name": "application_workspace_id_workspace_id_fk", 1913 1913 + "tableFrom": "application", 1914 1914 + "tableTo": "workspace", 1915 1915 + "columnsFrom": [ 1916 1916 + "workspace_id" 1917 1917 + ], 1918 1918 + "columnsTo": [ 1919 1919 + "id" 1920 1920 + ], 1921 1921 + "onDelete": "no action", 1922 1922 + "onUpdate": "no action" 1923 1923 + } 1924 1924 + }, 1925 1925 + "compositePrimaryKeys": {}, 1926 1926 + "uniqueConstraints": {} 1927 1927 + }, 1928 1928 + "maintenance": { 1929 1929 + "name": "maintenance", 1930 1930 + "columns": { 1931 1931 + "id": { 1932 1932 + "name": "id", 1933 1933 + "type": "integer", 1934 1934 + "primaryKey": true, 1935 1935 + "notNull": true, 1936 1936 + "autoincrement": false 1937 1937 + }, 1938 1938 + "title": { 1939 1939 + "name": "title", 1940 1940 + "type": "text(256)", 1941 1941 + "primaryKey": false, 1942 1942 + "notNull": true, 1943 1943 + "autoincrement": false 1944 1944 + }, 1945 1945 + "message": { 1946 1946 + "name": "message", 1947 1947 + "type": "text", 1948 1948 + "primaryKey": false, 1949 1949 + "notNull": true, 1950 1950 + "autoincrement": false 1951 1951 + }, 1952 1952 + "from": { 1953 1953 + "name": "from", 1954 1954 + "type": "integer", 1955 1955 + "primaryKey": false, 1956 1956 + "notNull": true, 1957 1957 + "autoincrement": false 1958 1958 + }, 1959 1959 + "to": { 1960 1960 + "name": "to", 1961 1961 + "type": "integer", 1962 1962 + "primaryKey": false, 1963 1963 + "notNull": true, 1964 1964 + "autoincrement": false 1965 1965 + }, 1966 1966 + "workspace_id": { 1967 1967 + "name": "workspace_id", 1968 1968 + "type": "integer", 1969 1969 + "primaryKey": false, 1970 1970 + "notNull": false, 1971 1971 + "autoincrement": false 1972 1972 + }, 1973 1973 + "page_id": { 1974 1974 + "name": "page_id", 1975 1975 + "type": "integer", 1976 1976 + "primaryKey": false, 1977 1977 + "notNull": false, 1978 1978 + "autoincrement": false 1979 1979 + }, 1980 1980 + "created_at": { 1981 1981 + "name": "created_at", 1982 1982 + "type": "integer", 1983 1983 + "primaryKey": false, 1984 1984 + "notNull": false, 1985 1985 + "autoincrement": false, 1986 1986 + "default": "(strftime('%s', 'now'))" 1987 1987 + }, 1988 1988 + "updated_at": { 1989 1989 + "name": "updated_at", 1990 1990 + "type": "integer", 1991 1991 + "primaryKey": false, 1992 1992 + "notNull": false, 1993 1993 + "autoincrement": false, 1994 1994 + "default": "(strftime('%s', 'now'))" 1995 1995 + } 1996 1996 + }, 1997 1997 + "indexes": {}, 1998 1998 + "foreignKeys": { 1999 1999 + "maintenance_workspace_id_workspace_id_fk": { 2000 2000 + "name": "maintenance_workspace_id_workspace_id_fk", 2001 2001 + "tableFrom": "maintenance", 2002 2002 + "tableTo": "workspace", 2003 2003 + "columnsFrom": [ 2004 2004 + "workspace_id" 2005 2005 + ], 2006 2006 + "columnsTo": [ 2007 2007 + "id" 2008 2008 + ], 2009 2009 + "onDelete": "no action", 2010 2010 + "onUpdate": "no action" 2011 2011 + }, 2012 2012 + "maintenance_page_id_page_id_fk": { 2013 2013 + "name": "maintenance_page_id_page_id_fk", 2014 2014 + "tableFrom": "maintenance", 2015 2015 + "tableTo": "page", 2016 2016 + "columnsFrom": [ 2017 2017 + "page_id" 2018 2018 + ], 2019 2019 + "columnsTo": [ 2020 2020 + "id" 2021 2021 + ], 2022 2022 + "onDelete": "no action", 2023 2023 + "onUpdate": "no action" 2024 2024 + } 2025 2025 + }, 2026 2026 + "compositePrimaryKeys": {}, 2027 2027 + "uniqueConstraints": {} 2028 2028 + }, 2029 2029 + "maintenance_to_monitor": { 2030 2030 + "name": "maintenance_to_monitor", 2031 2031 + "columns": { 2032 2032 + "monitor_id": { 2033 2033 + "name": "monitor_id", 2034 2034 + "type": "integer", 2035 2035 + "primaryKey": false, 2036 2036 + "notNull": true, 2037 2037 + "autoincrement": false 2038 2038 + }, 2039 2039 + "maintenance_id": { 2040 2040 + "name": "maintenance_id", 2041 2041 + "type": "integer", 2042 2042 + "primaryKey": false, 2043 2043 + "notNull": true, 2044 2044 + "autoincrement": false 2045 2045 + }, 2046 2046 + "created_at": { 2047 2047 + "name": "created_at", 2048 2048 + "type": "integer", 2049 2049 + "primaryKey": false, 2050 2050 + "notNull": false, 2051 2051 + "autoincrement": false, 2052 2052 + "default": "(strftime('%s', 'now'))" 2053 2053 + } 2054 2054 + }, 2055 2055 + "indexes": {}, 2056 2056 + "foreignKeys": { 2057 2057 + "maintenance_to_monitor_monitor_id_monitor_id_fk": { 2058 2058 + "name": "maintenance_to_monitor_monitor_id_monitor_id_fk", 2059 2059 + "tableFrom": "maintenance_to_monitor", 2060 2060 + "tableTo": "monitor", 2061 2061 + "columnsFrom": [ 2062 2062 + "monitor_id" 2063 2063 + ], 2064 2064 + "columnsTo": [ 2065 2065 + "id" 2066 2066 + ], 2067 2067 + "onDelete": "cascade", 2068 2068 + "onUpdate": "no action" 2069 2069 + }, 2070 2070 + "maintenance_to_monitor_maintenance_id_maintenance_id_fk": { 2071 2071 + "name": "maintenance_to_monitor_maintenance_id_maintenance_id_fk", 2072 2072 + "tableFrom": "maintenance_to_monitor", 2073 2073 + "tableTo": "maintenance", 2074 2074 + "columnsFrom": [ 2075 2075 + "maintenance_id" 2076 2076 + ], 2077 2077 + "columnsTo": [ 2078 2078 + "id" 2079 2079 + ], 2080 2080 + "onDelete": "cascade", 2081 2081 + "onUpdate": "no action" 2082 2082 + } 2083 2083 + }, 2084 2084 + "compositePrimaryKeys": { 2085 2085 + "maintenance_to_monitor_monitor_id_maintenance_id_pk": { 2086 2086 + "columns": [ 2087 2087 + "maintenance_id", 2088 2088 + "monitor_id" 2089 2089 + ], 2090 2090 + "name": "maintenance_to_monitor_monitor_id_maintenance_id_pk" 2091 2091 + } 2092 2092 + }, 2093 2093 + "uniqueConstraints": {} 2094 2094 + }, 2095 2095 + "check": { 2096 2096 + "name": "check", 2097 2097 + "columns": { 2098 2098 + "id": { 2099 2099 + "name": "id", 2100 2100 + "type": "integer", 2101 2101 + "primaryKey": true, 2102 2102 + "notNull": true, 2103 2103 + "autoincrement": true 2104 2104 + }, 2105 2105 + "regions": { 2106 2106 + "name": "regions", 2107 2107 + "type": "text", 2108 2108 + "primaryKey": false, 2109 2109 + "notNull": true, 2110 2110 + "autoincrement": false, 2111 2111 + "default": "''" 2112 2112 + }, 2113 2113 + "url": { 2114 2114 + "name": "url", 2115 2115 + "type": "text(4096)", 2116 2116 + "primaryKey": false, 2117 2117 + "notNull": true, 2118 2118 + "autoincrement": false 2119 2119 + }, 2120 2120 + "headers": { 2121 2121 + "name": "headers", 2122 2122 + "type": "text", 2123 2123 + "primaryKey": false, 2124 2124 + "notNull": false, 2125 2125 + "autoincrement": false, 2126 2126 + "default": "''" 2127 2127 + }, 2128 2128 + "body": { 2129 2129 + "name": "body", 2130 2130 + "type": "text", 2131 2131 + "primaryKey": false, 2132 2132 + "notNull": false, 2133 2133 + "autoincrement": false, 2134 2134 + "default": "''" 2135 2135 + }, 2136 2136 + "method": { 2137 2137 + "name": "method", 2138 2138 + "type": "text", 2139 2139 + "primaryKey": false, 2140 2140 + "notNull": false, 2141 2141 + "autoincrement": false, 2142 2142 + "default": "'GET'" 2143 2143 + }, 2144 2144 + "count_requests": { 2145 2145 + "name": "count_requests", 2146 2146 + "type": "integer", 2147 2147 + "primaryKey": false, 2148 2148 + "notNull": false, 2149 2149 + "autoincrement": false, 2150 2150 + "default": 1 2151 2151 + }, 2152 2152 + "workspace_id": { 2153 2153 + "name": "workspace_id", 2154 2154 + "type": "integer", 2155 2155 + "primaryKey": false, 2156 2156 + "notNull": false, 2157 2157 + "autoincrement": false 2158 2158 + }, 2159 2159 + "created_at": { 2160 2160 + "name": "created_at", 2161 2161 + "type": "integer", 2162 2162 + "primaryKey": false, 2163 2163 + "notNull": false, 2164 2164 + "autoincrement": false, 2165 2165 + "default": "(strftime('%s', 'now'))" 2166 2166 + } 2167 2167 + }, 2168 2168 + "indexes": {}, 2169 2169 + "foreignKeys": { 2170 2170 + "check_workspace_id_workspace_id_fk": { 2171 2171 + "name": "check_workspace_id_workspace_id_fk", 2172 2172 + "tableFrom": "check", 2173 2173 + "tableTo": "workspace", 2174 2174 + "columnsFrom": [ 2175 2175 + "workspace_id" 2176 2176 + ], 2177 2177 + "columnsTo": [ 2178 2178 + "id" 2179 2179 + ], 2180 2180 + "onDelete": "no action", 2181 2181 + "onUpdate": "no action" 2182 2182 + } 2183 2183 + }, 2184 2184 + "compositePrimaryKeys": {}, 2185 2185 + "uniqueConstraints": {} 2186 2186 + } 2187 2187 + }, 2188 2188 + "enums": {}, 2189 2189 + "_meta": { 2190 2190 + "schemas": {}, 2191 2191 + "tables": {}, 2192 2192 + "columns": {} 2193 2193 + }, 2194 2194 + "internal": { 2195 2195 + "indexes": {} 2196 2196 + } 2197 2197 + }

+7

packages/db/drizzle/meta/_journal.json

··· 253 253 "when": 1721159796428, 254 254 "tag": "0035_open_the_professor", 255 255 "breakpoints": true 256 256 + }, 257 257 + { 258 258 + "idx": 36, 259 259 + "version": "6", 260 260 + "when": 1723459608109, 261 261 + "tag": "0036_gifted_deathbird", 262 262 + "breakpoints": true 256 263 } 257 264 ] 258 265 }

+10 -1

packages/db/src/schema/monitors/constants.ts

··· 1 1 export const monitorMethods = ["GET", "POST", "HEAD"] as const; 2 2 export const monitorStatus = ["active", "error", "degraded"] as const; 3 3 4 4 - export const monitorJobTypes = ["website", "cron", "other"] as const; 4 4 + export const monitorJobTypes = [ 5 5 + "http", 6 6 + "tcp", 7 7 + "imcp", 8 8 + "udp", 9 9 + "dns", 10 10 + "ssl", 11 11 + // FIXME: remove this after the migration 12 12 + "other", 13 13 + ] as const;

+2 -2

packages/db/src/schema/monitors/monitor.ts

··· 18 18 export const monitor = sqliteTable("monitor", { 19 19 id: integer("id").primaryKey(), 20 20 jobType: text("job_type", { enum: monitorJobTypes }) 21 21 - .default("other") 21 21 + .default("http") 22 22 .notNull(), 23 23 periodicity: text("periodicity", { enum: monitorPeriodicity }) 24 24 .default("other") ··· 28 28 29 29 regions: text("regions").default("").notNull(), 30 30 31 31 - url: text("url", { length: 2048 }).notNull(), 31 31 + url: text("url", { length: 2048 }).notNull(), // URI 32 32 33 33 name: text("name", { length: 256 }).default("").notNull(), 34 34 description: text("description").default("").notNull(),

+1 -2

packages/db/src/schema/monitors/validation.ts

··· 43 43 export const selectMonitorSchema = createSelectSchema(monitor, { 44 44 periodicity: monitorPeriodicitySchema.default("10m"), 45 45 status: monitorStatusSchema.default("active"), 46 46 - jobType: monitorJobTypesSchema.default("other"), 46 46 + jobType: monitorJobTypesSchema.default("http"), 47 47 timeout: z.number().default(45), 48 48 regions: regionsToArraySchema.default([]), 49 49 }).extend({ ··· 59 59 export const insertMonitorSchema = createInsertSchema(monitor, { 60 60 name: z.string().min(1, "Name must be at least 1 character long"), 61 61 periodicity: monitorPeriodicitySchema.default("10m"), 62 62 - url: z.string().url(), // find a better way to not always start with "https://" including the `InputWithAddons` 63 62 status: monitorStatusSchema.default("active"), 64 63 regions: z.array(monitorRegionSchema).default([]).optional(), 65 64 headers: headersSchema.default([]),

+16

temp/main.go

··· 1 1 + package main 2 2 + 3 3 + import "fmt" 4 4 + 5 5 + type Person struct { 6 6 + Test int 7 7 + Other string 8 8 + } 9 9 + 10 10 + func HelloVet() { 11 11 + fmt.Println("Hello Vet") 12 12 + 13 13 + return 14 14 + 15 15 + fmt.Println("This line will never be executed") 16 16 + }