rootly

package
v1.86.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 23, 2026 License: BSD-3-Clause Imports: 20 Imported by: 0

README

Rootly Adapter

Entity External IDs

The Entity External ID is used directly as the API path segment. The adapter constructs URLs as:

{address}/{apiVersion}/{entityExternalID}?page[size]={pageSize}&page[number]={page}

The adapter is open-ended - any Rootly API resource name can be used as an entity external ID.

Entity External ID API Endpoint Description
incidents /v1/incidents Rootly incidents
users /v1/users Rootly users
teams /v1/teams Rootly teams

How It Works

The Entity External ID is appended directly as a path segment after the base URL and API version. Any valid Rootly API resource name will work.

Example URL:

https://api.rootly.com/v1/incidents?page[size]=100&page[number]=1&filter[status]=started&include=form_field_values

Configuration

Filters and includes are configured per entity using the entity external ID as the map key:

{
  "apiVersion": "v1",
  "filters": {
    "incidents": "status=started&severity=high",
    "users": "email=user@example.com"
  },
  "includes": {
    "incidents": "roles",
    "users": "role,email_addresses"
  }
}

Notes

  • The only supported API version is v1.
  • Pagination uses page-number-based pagination (page[size] + page[number]).

Adding New Entity External IDs

No code changes required. The adapter appends any entity external ID directly as a URL path segment. Simply configure a new entity in SGNL with the Rootly API resource name (e.g., services, environments, functionalities, severities) and it will work.

Filters and includes for the new entity can be added via the adapter configuration using the entity external ID as the map key.

Documentation

Overview

Generic JSON:API relationship resolver for Rootly API responses. Replaces {id, type} stubs in relationships with full included objects.

ABOUTME: Response processing utilities for Rootly JSON:API responses. ABOUTME: Handles enrichment of incident data with included relationships.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ConstructEndpoint

func ConstructEndpoint(request *Request) string

ConstructEndpoint constructs the endpoint URL for the given request.

func EnrichAllIncidentData added in v1.61.1

func EnrichAllIncidentData(data []map[string]any, included []map[string]any) []map[string]any

EnrichAllIncidentData enriches all incident data objects with their included items.

func EnrichIncidentData added in v1.61.1

func EnrichIncidentData(dataObject map[string]any, included []map[string]any) map[string]any

EnrichIncidentData enriches a single incident data object with its included items.

func NewAdapter

func NewAdapter(client Client) framework.Adapter[Config]

NewAdapter instantiates a new Adapter.

Types

type Adapter

type Adapter struct {
	RootlyClient Client
}

Adapter implements the framework.Adapter interface to query pages of objects from datasources.

func (*Adapter) GetPage

func (a *Adapter) GetPage(ctx context.Context, request *framework.Request[Config]) framework.Response

GetPage is called by SGNL's ingestion service to query a page of objects from a datasource.

func (*Adapter) RequestPageFromDatasource

func (a *Adapter) RequestPageFromDatasource(
	ctx context.Context, request *framework.Request[Config],
) framework.Response

RequestPageFromDatasource requests a page of objects from a datasource.

func (*Adapter) ValidateGetPageRequest

func (a *Adapter) ValidateGetPageRequest(ctx context.Context, request *framework.Request[Config]) *framework.Error

ValidateGetPageRequest validates the fields of the GetPage Request.

type Client

type Client interface {
	GetPage(ctx context.Context, request *Request) (*Response, *framework.Error)
}

Client is a client that allows querying the Rootly datasource which contains JSON objects.

func NewClient

func NewClient(client *http.Client) Client

NewClient returns a Client to query the datasource.

type Config

type Config struct {
	// Common configuration
	*config.CommonConfig

	// APIVersion is the Rootly API version to use for requests.
	APIVersion string `json:"apiVersion,omitempty"`

	// Filters contains a map of filters for each entity associated with this
	// datasource. The key is the entity's external_name, and the value is the filter string.
	Filters map[string]string `json:"filters,omitempty"`

	// Includes contains a map of fields to include for each entity associated with this
	// datasource. The key is the entity's external_name, and the value is a comma-separated
	// list of fields to include in the response.
	Includes map[string]string `json:"includes,omitempty"`
}

Config is the configuration passed in each GetPage calls to the adapter. Adapter configuration example: nolint: godot

{
	"requestTimeoutSeconds": 10,
	"apiVersion": "v1",
	"filters": {
		"users": "email=rufus_raynor@hegmann.test",
		"incidents": "status=started&severity=high"
	},
	"includes": {
		"users": "role,email_addresses",
		"incidents": "roles"
	}
}

func (*Config) Validate

func (c *Config) Validate(_ context.Context) error

ValidateConfig validates that a Config received in a GetPage call is valid.

type Datasource

type Datasource struct {
	Client *http.Client
}

Datasource directly implements a Client interface to allow querying an external datasource.

func (*Datasource) GetPage

func (d *Datasource) GetPage(ctx context.Context, request *Request) (*Response, *framework.Error)

type DatasourceErrorResponse

type DatasourceErrorResponse struct {
	Errors []struct {
		Title  string `json:"title"`
		Detail string `json:"detail"`
		Status string `json:"status"`
	} `json:"errors"`
}

type DatasourceResponse

type DatasourceResponse struct {
	Data     []map[string]any `json:"data"`
	Included []map[string]any `json:"included,omitempty"`
	Meta     struct {
		Page       int `json:"current_page"`
		Pages      int `json:"total_pages"`
		TotalCount int `json:"total_count"`
	} `json:"meta"`
}

type IncludedItemProcessor added in v1.61.1

type IncludedItemProcessor struct {
	// contains filtered or unexported fields
}

IncludedItemProcessor processes included items and enriches incident data. It handles the extraction and flattening of nested relationships from Rootly's JSON:API format.

func NewIncludedItemProcessor added in v1.61.1

func NewIncludedItemProcessor(incidentID string, included []map[string]any) *IncludedItemProcessor

NewIncludedItemProcessor creates a new processor for the given incident ID.

func (*IncludedItemProcessor) ExtractEntities added in v1.61.1

func (p *IncludedItemProcessor) ExtractEntities() map[string][]any

ExtractEntities extracts and flattens entities of a specific type from all matching included items. Each entity will have a field_id property added for filtering. Returns a map where keys are entity types (e.g., "selected_users") and values are slices of flattened entities ([]any), to ensure compatibility with JSONPath filter expressions.

func (*IncludedItemProcessor) FindMatching added in v1.61.1

func (p *IncludedItemProcessor) FindMatching() []map[string]any

FindMatching returns all included items that belong to this incident. It matches based on the incident_id field in the attributes.

func (*IncludedItemProcessor) ProcessAndExpand added in v1.61.1

func (p *IncludedItemProcessor) ProcessAndExpand() []any

ProcessAndExpand processes matching included items and expands nested arrays. It flattens all selected_* entity types into individual items with metadata. Returns []any to ensure compatibility with JSONPath filter expressions.

type Request

type Request struct {
	// BaseURL is the Base URL of the datasource to query.
	BaseURL string

	// HTTPAuthorization is the HTTP authorization header value to authenticate a request.
	// This will be provided in the form "Bearer <token>".
	HTTPAuthorization string

	// PageSize is the maximum number of objects to return from the entity.
	PageSize int64

	// EntityExternalID is the external ID of the entity.
	// The external ID should match the API's resource name.
	EntityExternalID string

	// Cursor identifies the first object of the page to return, as returned by
	// the last request for the entity.
	// nil in the request for the first page.
	Cursor *string

	// Filter contains the optional filter to apply to the current request.
	Filter string

	// Includes contains the optional list of fields to include in the response.
	Includes string

	// RequestTimeoutSeconds is the timeout duration for requests made to datasources.
	// This should be set to the number of seconds to wait before timing out.
	RequestTimeoutSeconds int
}

Request is a request to Rootly.

type Response

type Response struct {
	// Objects contains the list of objects returned by the datasource.
	Objects []map[string]any

	// NextCursor identifies the first object of the next page to return.
	// nil if the current page is the last page for the entity.
	NextCursor *string
}

Response is a response returned by the datasource.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL