Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
package server
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"strconv"
"connectrpc.com/connect"
"github.com/openstatushq/openstatus/apps/private-location/internal/database"
"github.com/openstatushq/openstatus/apps/private-location/internal/models"
private_locationv1 "github.com/openstatushq/openstatus/apps/private-location/proto/private_location/v1"
)
// Converts models.NumberComparator to proto NumberComparator
func convertNumberComparator(m models.NumberComparator) private_locationv1.NumberComparator {
switch m {
case models.NumberNotEquals:
return private_locationv1.NumberComparator_NUMBER_COMPARATOR_NOT_EQUAL
case models.NumberEquals:
return private_locationv1.NumberComparator_NUMBER_COMPARATOR_EQUAL
case models.NumberGreaterThan:
return private_locationv1.NumberComparator_NUMBER_COMPARATOR_GREATER_THAN
case models.NumberGreaterThanEqual:
return private_locationv1.NumberComparator_NUMBER_COMPARATOR_GREATER_THAN_OR_EQUAL
case models.NumberLowerThan:
return private_locationv1.NumberComparator_NUMBER_COMPARATOR_LESS_THAN
case models.NumberLowerThanEqual:
return private_locationv1.NumberComparator_NUMBER_COMPARATOR_LESS_THAN_OR_EQUAL
default:
return private_locationv1.NumberComparator_NUMBER_COMPARATOR_UNSPECIFIED
}
}
// Converts models.StringComparator to proto StringComparator
func convertStringComparator(m models.StringComparator) private_locationv1.StringComparator {
switch m {
case models.StringNotEquals:
return private_locationv1.StringComparator_STRING_COMPARATOR_NOT_EQUAL
case models.StringEquals:
return private_locationv1.StringComparator_STRING_COMPARATOR_EQUAL
case models.StringContains:
return private_locationv1.StringComparator_STRING_COMPARATOR_CONTAINS
case models.StringNotContains:
return private_locationv1.StringComparator_STRING_COMPARATOR_NOT_CONTAINS
case models.StringEmpty:
return private_locationv1.StringComparator_STRING_COMPARATOR_EMPTY
case models.StringNotEmpty:
return private_locationv1.StringComparator_STRING_COMPARATOR_NOT_EMPTY
default:
return private_locationv1.StringComparator_STRING_COMPARATOR_UNSPECIFIED
}
}
// Converts models.RecordComparator to proto RecordComparator
func convertRecordComparator(m models.RecordComparator) private_locationv1.RecordComparator {
switch m {
case models.RecordEquals:
return private_locationv1.RecordComparator_RECORD_COMPARATOR_EQUAL
case models.RecordNotEquals:
return private_locationv1.RecordComparator_RECORD_COMPARATOR_NOT_EQUAL
case models.RecordContains:
return private_locationv1.RecordComparator_RECORD_COMPARATOR_CONTAINS
case models.RecordNotContains:
return private_locationv1.RecordComparator_RECORD_COMPARATOR_NOT_CONTAINS
default:
return private_locationv1.RecordComparator_RECORD_COMPARATOR_UNSPECIFIED
}
}
// addParseError records a parsing error in the wide event context
func addParseError(ctx context.Context, errorType string, err error) {
if holder := GetEvent(ctx); holder != nil {
errors, ok := holder.Event["parse_errors"].([]map[string]any)
if !ok {
errors = []map[string]any{}
}
errors = append(errors, map[string]any{
"type": errorType,
"message": err.Error(),
})
holder.Event["parse_errors"] = errors
}
}
// Helper to parse assertions
func ParseAssertions(ctx context.Context, assertions sql.NullString) (
statusAssertions []*private_locationv1.StatusCodeAssertion,
headerAssertions []*private_locationv1.HeaderAssertion,
bodyAssertions []*private_locationv1.BodyAssertion,
) {
if !assertions.Valid {
return
}
var rawAssertions []json.RawMessage
if err := json.Unmarshal([]byte(assertions.String), &rawAssertions); err != nil {
addParseError(ctx, "assertions_unmarshal", err)
return
}
for _, a := range rawAssertions {
var assert models.Assertion
if err := json.Unmarshal(a, &assert); err != nil {
addParseError(ctx, "assertion_unmarshal", err)
continue
}
switch assert.AssertionType {
case models.AssertionStatus:
var target models.StatusTarget
if err := json.Unmarshal(a, &target); err != nil {
addParseError(ctx, "status_target_unmarshal", err)
continue
}
statusAssertions = append(statusAssertions, &private_locationv1.StatusCodeAssertion{
Target: target.Target,
Comparator: convertNumberComparator(target.Comparator),
})
case models.AssertionHeader:
var target models.HeaderTarget
if err := json.Unmarshal(a, &target); err != nil {
addParseError(ctx, "header_target_unmarshal", err)
continue
}
headerAssertions = append(headerAssertions, &private_locationv1.HeaderAssertion{
Key: target.Key,
Target: target.Target,
Comparator: convertStringComparator(target.Comparator),
})
case models.AssertionTextBody:
var target models.BodyString
if err := json.Unmarshal(a, &target); err != nil {
addParseError(ctx, "body_target_unmarshal", err)
continue
}
bodyAssertions = append(bodyAssertions, &private_locationv1.BodyAssertion{
Target: target.Target,
Comparator: convertStringComparator(target.Comparator),
})
}
}
return
}
// Helper to parse DNS record assertions
func ParseRecordAssertions(ctx context.Context, assertions sql.NullString) []*private_locationv1.RecordAssertion {
if !assertions.Valid {
return nil
}
var rawAssertions []json.RawMessage
if err := json.Unmarshal([]byte(assertions.String), &rawAssertions); err != nil {
addParseError(ctx, "record_assertions_unmarshal", err)
return nil
}
var recordAssertions []*private_locationv1.RecordAssertion
for _, a := range rawAssertions {
var assert models.Assertion
if err := json.Unmarshal(a, &assert); err != nil {
addParseError(ctx, "record_assertion_unmarshal", err)
continue
}
if assert.AssertionType == models.AssertionDnsRecord {
var target models.RecordTarget
if err := json.Unmarshal(a, &target); err != nil {
addParseError(ctx, "record_target_unmarshal", err)
continue
}
recordAssertions = append(recordAssertions, &private_locationv1.RecordAssertion{
Record: target.Key,
Comparator: convertRecordComparator(target.Comparator),
Target: target.Target,
})
}
}
return recordAssertions
}
func (h *privateLocationHandler) Monitors(ctx context.Context, req *connect.Request[private_locationv1.MonitorsRequest]) (*connect.Response[private_locationv1.MonitorsResponse], error) {
token := req.Header().Get("openstatus-token")
if token == "" {
return nil, connect.NewError(connect.CodeUnauthenticated, ErrMissingToken)
}
locationCtx, cancelLocation := context.WithTimeout(ctx, dbTimeout)
defer cancelLocation()
var location database.PrivateLocation
if err := h.db.GetContext(locationCtx, &location, "SELECT id, name FROM private_location WHERE token = ?", token); err != nil {
// An unknown token used to fall through to an empty monitor list, so a
// probe configured with a typo looked healthy while checking nothing.
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeUnauthenticated, ErrPrivateLocationNotFound)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
monitorsCtx, cancelMonitors := context.WithTimeout(ctx, dbTimeout)
defer cancelMonitors()
var monitors []database.Monitor
err := h.db.SelectContext(monitorsCtx, &monitors, "SELECT monitor.id, monitor.job_type, monitor.url, monitor.periodicity, monitor.method, monitor.body, monitor.timeout, monitor.degraded_after, monitor.follow_redirects, monitor.headers, monitor.assertions, monitor.workspace_id, monitor.retry, monitor.otel_endpoint, monitor.otel_headers, monitor.grpc_service, monitor.grpc_tls FROM monitor JOIN private_location_to_monitor a ON monitor.id = a.monitor_id JOIN private_location b ON a.private_location_id = b.id WHERE b.token = ? AND monitor.deleted_at IS NULL and monitor.active = 1", token)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
httpMonitors, tcpMonitors, dnsMonitors, icmpMonitors, grpcMonitors, workspaceId := mapMonitors(ctx, monitors)
// Enrich wide event with monitor counts
if holder := GetEvent(ctx); holder != nil {
holder.Event["private_location"] = map[string]any{
"workspace_id": workspaceId,
"http_monitors": len(httpMonitors),
"tcp_monitors": len(tcpMonitors),
"dns_monitors": len(dnsMonitors),
"icmp_monitors": len(icmpMonitors),
"grpc_monitors": len(grpcMonitors),
"total_monitors": len(monitors),
}
}
return connect.NewResponse(&private_locationv1.MonitorsResponse{
HttpMonitors: httpMonitors,
TcpMonitors: tcpMonitors,
DnsMonitors: dnsMonitors,
IcmpMonitors: icmpMonitors,
GrpcMonitors: grpcMonitors,
Region: location.Name,
}), nil
}
func mapMonitors(ctx context.Context, monitors []database.Monitor) (
[]*private_locationv1.HTTPMonitor,
[]*private_locationv1.TCPMonitor,
[]*private_locationv1.DNSMonitor,
[]*private_locationv1.ICMPMonitor,
[]*private_locationv1.GRPCMonitor,
int,
) {
var workspaceId int
var httpMonitors []*private_locationv1.HTTPMonitor
var tcpMonitors []*private_locationv1.TCPMonitor
var dnsMonitors []*private_locationv1.DNSMonitor
var icmpMonitors []*private_locationv1.ICMPMonitor
var grpcMonitors []*private_locationv1.GRPCMonitor
for _, monitor := range monitors {
if workspaceId == 0 {
workspaceId = monitor.WorkspaceID
}
switch monitor.JobType {
case database.JobTypeHTTP:
httpMonitors = append(httpMonitors, toHTTPMonitor(ctx, monitor))
case database.JobTypeTCP:
tcpMonitors = append(tcpMonitors, toTCPMonitor(ctx, monitor))
case database.JobTypeDNS:
dnsMonitors = append(dnsMonitors, toDNSMonitor(ctx, monitor))
case database.JobTypeICMP:
icmpMonitors = append(icmpMonitors, toICMPMonitor(ctx, monitor))
case database.JobTypeGRPC:
grpcMonitors = append(grpcMonitors, toGRPCMonitor(ctx, monitor))
default:
// Without this a job type the checker does not know is dropped in
// silence: no row, no log, and a monitor that reads as "no data yet".
addParseError(ctx, "unsupported_job_type", fmt.Errorf("monitor %d has job type %q", monitor.ID, monitor.JobType))
}
}
return httpMonitors, tcpMonitors, dnsMonitors, icmpMonitors, grpcMonitors, workspaceId
}
func toHTTPMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.HTTPMonitor {
var headers []*private_locationv1.Headers
if err := json.Unmarshal([]byte(monitor.Headers), &headers); err != nil {
addParseError(ctx, "headers_unmarshal", err)
headers = nil
}
statusAssertions, headerAssertions, bodyAssertions := ParseAssertions(ctx, monitor.Assertions)
return &private_locationv1.HTTPMonitor{
Url: monitor.URL,
Periodicity: monitor.Periodicity,
Id: strconv.Itoa(monitor.ID),
Method: monitor.Method,
Body: monitor.Body,
Timeout: monitor.Timeout,
DegradedAt: &monitor.DegradedAfter.Int64,
Retry: int64(monitor.Retry),
FollowRedirects: monitor.FollowRedirects,
Headers: headers,
StatusCodeAssertions: statusAssertions,
HeaderAssertions: headerAssertions,
BodyAssertions: bodyAssertions,
OtelConfig: buildOtelConfig(ctx, monitor),
}
}
func toTCPMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.TCPMonitor {
return &private_locationv1.TCPMonitor{
Id: strconv.Itoa(monitor.ID),
Uri: monitor.URL,
Timeout: monitor.Timeout,
DegradedAt: &monitor.DegradedAfter.Int64,
Periodicity: monitor.Periodicity,
Retry: int64(monitor.Retry),
OtelConfig: buildOtelConfig(ctx, monitor),
}
}
func toICMPMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.ICMPMonitor {
return &private_locationv1.ICMPMonitor{
Id: strconv.Itoa(monitor.ID),
Uri: monitor.URL,
Timeout: monitor.Timeout,
DegradedAt: &monitor.DegradedAfter.Int64,
Periodicity: monitor.Periodicity,
Retry: int64(monitor.Retry),
OtelConfig: buildOtelConfig(ctx, monitor),
}
}
func toGRPCMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.GRPCMonitor {
var metadata []*private_locationv1.Headers
if monitor.Headers != "" {
if err := json.Unmarshal([]byte(monitor.Headers), &metadata); err != nil {
addParseError(ctx, "metadata_unmarshal", err)
metadata = nil
}
}
tlsMode := monitor.GrpcTls.String
if tlsMode == "" {
tlsMode = "tls"
}
return &private_locationv1.GRPCMonitor{
Id: strconv.Itoa(monitor.ID),
Uri: monitor.URL,
Timeout: monitor.Timeout,
DegradedAt: &monitor.DegradedAfter.Int64,
Periodicity: monitor.Periodicity,
Retry: int64(monitor.Retry),
Service: monitor.GrpcService.String,
TlsMode: tlsMode,
Metadata: metadata,
OtelConfig: buildOtelConfig(ctx, monitor),
}
}
func toDNSMonitor(ctx context.Context, monitor database.Monitor) *private_locationv1.DNSMonitor {
return &private_locationv1.DNSMonitor{
Id: strconv.Itoa(monitor.ID),
Uri: monitor.URL,
Timeout: monitor.Timeout,
DegradedAt: &monitor.DegradedAfter.Int64,
Periodicity: monitor.Periodicity,
Retry: int64(monitor.Retry),
RecordAssertions: ParseRecordAssertions(ctx, monitor.Assertions),
}
}
// buildOtelConfig maps a monitor's stored OTel settings to the proto config,
// returning nil when no endpoint is configured so the checker skips OTel.
func buildOtelConfig(ctx context.Context, monitor database.Monitor) *private_locationv1.OtelConfig {
if !monitor.OtelEndpoint.Valid || monitor.OtelEndpoint.String == "" {
return nil
}
return &private_locationv1.OtelConfig{
Endpoint: monitor.OtelEndpoint.String,
Headers: ParseOtelHeaders(ctx, monitor.OtelHeaders),
}
}
// ParseOtelHeaders decodes the stored otel_headers JSON array ([]{key,value}),
// returning nil for a null/empty/invalid value.
func ParseOtelHeaders(ctx context.Context, raw sql.NullString) []*private_locationv1.Headers {
if !raw.Valid || raw.String == "" {
return nil
}
var headers []*private_locationv1.Headers
if err := json.Unmarshal([]byte(raw.String), &headers); err != nil {
addParseError(ctx, "otel_headers_unmarshal", err)
return nil
}
return headers
}