checkly

README

Checkly GO SDK

🦦 Go SDK library for use with the Checkly API

👀 Overview

This project is a Go SDK for Checkly monitoring service. It allows you to handle your checks, check groups, snippets, environments variables and everything you can do with our REST API.

While you can manage your Checkly account entirely in Go code, using this library, you may prefer to use Terraform. In that case, you can use the Checkly Terraform provider (which is built on top of this library):

🔧 How to use?

To use the client library with your Checkly account, you will need an API Key for the account. Go to the Account Settings: API Keys page and click 'Create API Key'.

Import the SDK

import checkly "github.com/checkly/checkly-go-sdk"

Create a client

Create a new Client by calling checkly.NewClient() with your API key:

baseUrl := "https://api.checklyhq.com"
apiKey := os.Getenv("CHECKLY_API_KEY")
accountId := os.Getenv("CHECKLY_ACCOUNT_ID")
client := checkly.NewClient(
	baseUrl,
	apiKey,
	nil, //custom http client, defaults to http.DefaultClient
	nil, //io.Writer to output debug messages
)

client.SetAccountId(accountId)

⚠️ Account ID is only required if you are using new User API keys. If you are using legacy Account API keys you can omit it.

Note: if you don't have an API key, you can create one at here

Create a check

Once you have a client, you can create a check. First, populate a Check struct with the parameters you want:

check := checkly.Check{
	Name:                 "My API Check",
	Type:                 checkly.TypeAPI,
	Frequency:            5,
	DegradedResponseTime: 5000,
	MaxResponseTime:      15000,
	Activated:            true,
	Muted:                false,
	ShouldFail:           false,
	DoubleCheck:          false,
	SSLCheck:             true,
	LocalSetupScript:     "",
	LocalTearDownScript:  "",
	Locations: []string{
		"eu-west-1",
		"ap-northeast-2",
	},
	Tags: []string{
		"foo",
		"bar",
	},
	AlertSettings:          alertSettings,
	UseGlobalAlertSettings: false,
	Request: checkly.Request{
		Method: http.MethodGet,
		URL:    "http://example.com",
		Headers: []checkly.KeyValue{
			{
				Key:   "X-Test",
				Value: "foo",
			},
		},
		QueryParameters: []checkly.KeyValue{
			{
				Key:   "query",
				Value: "foo",
			},
		},
		Assertions: []checkly.Assertion{
			{
				Source:     checkly.StatusCode,
				Comparison: checkly.Equals,
				Target:     "200",
			},
		},
		Body:     "",
		BodyType: "NONE",
	},
}

Now you can pass it to client.Create() to create a check. This returns the newly-created Check object, or an error if there was a problem:

ctx := context.WithTimeout(context.Background(), time.Second * 5)
check, err := client.Create(ctx, check)

For browser checks, the options are slightly different:

check := checkly.Check{
	Name:          "My Browser Check",
	Type:          checkly.TypeBrowser,
	Frequency:     5,
	Activated:     true,
	Muted:         false,
	ShouldFail:    false,
	DoubleCheck:   false,
	SSLCheck:      true,
	Locations:     []string{"eu-west-1"},
	AlertSettings: alertSettings,
	Script: `const assert = require("chai").assert;
	const puppeteer = require("puppeteer");

	const browser = await puppeteer.launch();
	const page = await browser.newPage();
	await page.goto("https://example.com");
	const title = await page.title();

	assert.equal(title, "Example Site");
	await browser.close();`,
	EnvironmentVariables: []checkly.EnvironmentVariable{
		{
			Key:   "HELLO",
			Value: "Hello world",
		},
	},
	Request: checkly.Request{
		Method: http.MethodGet,
		URL:    "http://example.com",
	},
}

Retrieve a check

client.Get(ctx, ID) finds an existing check by ID and returns a Check struct containing its details:

check, err := client.Get(ctx, "87dd7a8d-f6fd-46c0-b73c-b35712f56d72")
fmt.Println(check.Name)
// Output: My Awesome Check

Update a check

client.Update(ctx, ID, check) updates an existing check with the specified details. For example, to change the name of a check:

ID := "87dd7a8d-f6fd-46c0-b73c-b35712f56d72"
check, err := client.Get(ctx, ID)
check.Name = "My updated check name"
updatedCheck, err = client.Update(ctx, ID, check)

Delete a check

Use client.Delete(ctx, ID) to delete a check by ID.

err := client.Delete(ctx, "73d29ea2-6540-4bb5-967e-e07fa2c9465e")

Create a check group

Checkly checks can be combined into a group, so that you can configure default values for all the checks within it:

var wantGroup = checkly.Group{
	Name:        "test",
	Activated:   true,
	Muted:       false,
	Tags:        []string{"auto"},
	Locations:   []string{"eu-west-1"},
	Concurrency: 3,
	APICheckDefaults: checkly.APICheckDefaults{
		BaseURL: "example.com/api/test",
		Headers: []checkly.KeyValue{
			{
				Key:   "X-Test",
				Value: "foo",
			},
		},
		QueryParameters: []checkly.KeyValue{
			{
				Key:   "query",
				Value: "foo",
			},
		},
		Assertions: []checkly.Assertion{
			{
				Source:     checkly.StatusCode,
				Comparison: checkly.Equals,
				Target:     "200",
			},
		},
		BasicAuth: checkly.BasicAuth{
			Username: "user",
			Password: "pass",
		},
	},
	EnvironmentVariables: []checkly.EnvironmentVariable{
		{
			Key:   "ENVTEST",
			Value: "Hello world",
		},
	},
	DoubleCheck:            true,
	UseGlobalAlertSettings: false,
	AlertSettings: checkly.AlertSettings{
		EscalationType: checkly.RunBased,
		RunBasedEscalation: checkly.RunBasedEscalation{
			FailedRunThreshold: 1,
		},
		TimeBasedEscalation: checkly.TimeBasedEscalation{
			MinutesFailingThreshold: 5,
		},
		Reminders: checkly.Reminders{
			Amount:   0,
			Interval: 5,
		},
		SSLCertificates: checkly.SSLCertificates{
			Enabled:        true,
			AlertThreshold: 30,
		},
	},
	AlertChannelSubscriptions: []checkly.Subscription{
		{
			Activated: true,
		},
	},
	LocalSetupScript:    "setup-test",
	LocalTearDownScript: "teardown-test",
}
group, err := client.CreateGroup(ctx, wantGroup)

👌 A complete example program!

You can see an example program which creates a Checkly check in the examples/demo folder.

🧪 Testing

There are two different set of tests: unit test and integration tests. Both can be run with the go test command.

$ go test ./... # unit tests
$ go test ./... -tags=integration # integration tests

🐛 Debugging

If things aren't working as you expect, you can pass an io.Writer to checkly.NewClient's fourth arg to receive debug output. If debug is non-nil, then all API requests and responses will be dumped to the specified writer (for example, os.Stderr).

Regardless of the debug setting, if a request fails with HTTP status 400 Bad Request), the full response will be dumped (to standard error if no debug writer is set):

debugOutput := os.Stderr
client.NewClient(
	"https://api.checklyhq.com",
	"your-api-key",
	nil,
	debugOutput,
)

Example request and response dump:

POST /v1/checks HTTP/1.1
Host: api-test.checklyhq.com
User-Agent: Go-http-client/1.1
Content-Length: 1078
Authorization: Bearer XXX
Content-Type: application/json
Accept-Encoding: gzip

{"id":"","name":"test","checkType":"API","frequency":10,"activated":true,
"muted":false,"shouldFail":false,"locations":["eu-west-1"],
"degradedResponseTime":15000,"maxResponseTime":30000,"script":"foo",
"environmentVariables":[{"key":"ENVTEST","value":"Hello world","locked":false}],
"doubleCheck":true,"tags":["foo","bar"],"sslCheck":true,
"localSetupScript":"setitup","localTearDownScript":"tearitdown","alertSettings":
{"escalationType":"RUN_BASED","runBasedEscalation":{"failedRunThreshold":1},
"timeBasedEscalation":{"minutesFailingThreshold":5},"reminders":{"interval":5},
"sslCertificates":{"enabled":false,"alertThreshold":30}},
"useGlobalAlertSettings":false,"request":{"method":"GET","url":"https://example.
com","followRedirects":false,"body":"","bodyType":"NONE","headers":[
{"key":"X-Test","value":"foo","locked":false}],"queryParameters":[
{"key":"query","value":"foo","locked":false}],"assertions":[
{"edit":false,"order":0,"arrayIndex":0,"arraySelector":0,
"source":"STATUS_CODE","property":"","comparison":"EQUALS",
"target":"200"}],"basicAuth":{"username":"","password":""}}}

HTTP/1.1 201 Created
Transfer-Encoding: chunked
Cache-Control: no-cache
Connection: keep-alive
Content-Type: application/json; charset=utf-8
Date: Thu, 28 May 2020 11:18:31 GMT
Server: Cowboy
Vary: origin,accept-encoding
Via: 1.1 vegur

4ea
{"name":"test","checkType":"API","frequency":10,"activated":true,"muted":false,
"shouldFail":false,"locations":["eu-west-1"],"degradedResponseTime":15000,
"maxResponseTime":30000,"script":"foo","environmentVariables":[{"key":"ENVTEST",
"value":"Hello world","locked":false}],"doubleCheck":true,"tags":["foo","bar"],
"sslCheck":true,"localSetupScript":"setitup","localTearDownScript":"tearitdown",
"alertSettings":{"escalationType":"RUN_BASED","runBasedEscalation":
{"failedRunThreshold":1},"timeBasedEscalation":{"minutesFailingThreshold":5},
"reminders":{"interval":5,"amount":0},"sslCertificates":{"enabled":false,
"alertThreshold":30}},"useGlobalAlertSettings":false,"request":{"method":"GET",
"url":"https://example.com","followRedirects":false,"body":"","bodyType":"NONE",
"headers":[{"key":"X-Test","value":"foo","locked":false}],"queryParameters":[
{"key":"query","value":"foo","locked":false}],"assertions":[
{"source":"STATUS_CODE","property":"","comparison":"EQUALS","target":"200"}],
"basicAuth":{"username":"","password":""}},"setupSnippetId":null,
"tearDownSnippetId":null,"groupId":null,"groupOrder":null,
"alertChannelSubscriptions":[{"activated":true,"alertChannelId":35}],
"created_at":"2020-05-28T11:18:31.280Z",
"id":"29815146-8ab5-492d-a092-9912c1ab8333"}
0

🚀 Release

Release process is automatically handled using tags and the release GitHub Action. To create a new release, you have to create and push a new version tag: vX.X.X

🔢 When creating a new tag, be sure to follow SemVer.

📝 Bugs and feature requests

If you find a bug in the checkly client or library, please open an issue. Similarly, if you'd like a feature added or improved, let me know via an issue.

Not all the functionality of the Checkly API is implemented yet.

Pull requests welcome!

📄 License

MIT

_{Delightful Active Monitoring for Developers
From Checkly with ♥️}

Documentation

Index

• Constants
• func AlertChannelConfigFromJSON(channelType string, cfgJSON []byte) (interface{}, error)
• type APICheckDefaults
• type AlertChannel
  • func (a *AlertChannel) GetConfig() (cfg map[string]interface{})
  • func (a *AlertChannel) SetConfig(cfg interface{})
• type AlertChannelEmail
• type AlertChannelOpsgenie
• type AlertChannelPagerduty
• type AlertChannelSMS
• type AlertChannelSlack
• type AlertChannelSubscription
• type AlertChannelWebhook
• type AlertSettings
• type ApiCheckResult
• type Assertion
• type BasicAuth
• type BrowserCheckResult
• type Check
• type CheckResult
• type CheckResultsFilter
• type CheckType
• type Client
  • func NewClient(baseURL, apiKey string, httpClient *http.Client, debug io.Writer) Client
• type Dashboard
• type EnvironmentVariable
• type Group
• type KeyValue
• type MaintenanceWindow
• type Reminders
• type Request
• type RunBasedEscalation
• type SSLCertificates
• type Snippet
• type TimeBasedEscalation
• type TriggerCheck
• type TriggerGroup

Constants

const (
	AlertTypeEmail     = "EMAIL"
	AlertTypeSlack     = "SLACK"
	AlertTypeWebhook   = "WEBHOOK"
	AlertTypeSMS       = "SMS"
	AlertTypePagerduty = "PAGERDUTY"
	AlertTypeOpsgenie  = "OPSGENIE"
)

const Contains = "CONTAINS"

Contains asserts that the source contains a specified value.

const Equals = "EQUALS"

Equals asserts that the source and target are equal.

const GreaterThan = "GREATER_THAN"

GreaterThan asserts that the source is greater than the target.

const Headers = "HEADERS"

Headers identifies the HTTP headers as an assertion source.

const IsEmpty = "IS_EMPTY"

IsEmpty asserts that the source is empty.

const JSONBody = "JSON_BODY"

JSONBody identifies the JSON body data as an assertion source.

const LessThan = "LESS_THAN"

LessThan asserts that the source is less than the target.

const NotContains = "NOT_CONTAINS"

NotContains asserts that the source does not contain a specified value.

const NotEmpty = "NOT_EMPTY"

NotEmpty asserts that the source is not empty.

const NotEquals = "NOT_EQUALS"

NotEquals asserts that the source and target are not equal.

const ResponseTime = "RESPONSE_TIME"

ResponseTime identifies the response time as an assertion source.

const RunBased = "RUN_BASED"

RunBased identifies a run-based escalation type, for use with an AlertSettings.

const StatusCode = "STATUS_CODE"

StatusCode identifies the HTTP status code as an assertion source.

const TextBody = "TEXT_BODY"

TextBody identifies the response body text as an assertion source.

const TimeBased = "TIME_BASED"

TimeBased identifies a time-based escalation type, for use with an AlertSettings.

const TypeAPI = "API"

TypeAPI is used to identify an API check.

const TypeBrowser = "BROWSER"

TypeBrowser is used to identify a browser check.

Functions

func AlertChannelConfigFromJSON

func AlertChannelConfigFromJSON(channelType string, cfgJSON []byte) (interface{}, error)

AlertChannelConfigFromJSON gets AlertChannel.config from JSON

Types

type APICheckDefaults

type APICheckDefaults struct {
	BaseURL         string      `json:"url"`
	Headers         []KeyValue  `json:"headers,omitempty"`
	QueryParameters []KeyValue  `json:"queryParameters,omitempty"`
	Assertions      []Assertion `json:"assertions,omitempty"`
	BasicAuth       BasicAuth   `json:"basicAuth,omitempty"`
}

APICheckDefaults represents the default settings for API checks within a given group.

type AlertChannel

type AlertChannel struct {
	ID                 int64                  `json:"id,omitempty"`
	Type               string                 `json:"type"`
	CreatedAt          time.Time              `json:"created_at"`
	UpdatedAt          time.Time              `json:"updated_at"`
	Email              *AlertChannelEmail     `json:"-"`
	Slack              *AlertChannelSlack     `json:"-"`
	SMS                *AlertChannelSMS       `json:"-"`
	Opsgenie           *AlertChannelOpsgenie  `json:"-"`
	Webhook            *AlertChannelWebhook   `json:"-"`
	Pagerduty          *AlertChannelPagerduty `json:"-"`
	SendRecovery       *bool                  `json:"sendRecovery"`
	SendFailure        *bool                  `json:"sendFailure"`
	SendDegraded       *bool                  `json:"sendDegraded"`
	SSLExpiry          *bool                  `json:"sslExpiry"`
	SSLExpiryThreshold *int                   `json:"sslExpiryThreshold"`
}

AlertChannel represents an alert channel and its subscribed checks. The API defines this data as read-only.

func (*AlertChannel) GetConfig

func (a *AlertChannel) GetConfig() (cfg map[string]interface{})

GetConfig gets the config of the alert channel based on it's type

func (*AlertChannel) SetConfig

func (a *AlertChannel) SetConfig(cfg interface{})

SetConfig sets config of alert channel based on it's type

type AlertChannelEmail

type AlertChannelEmail struct {
	Address string `json:"address"`
}

AlertChannelEmail defines a type for an email alert channel

type AlertChannelOpsgenie

type AlertChannelOpsgenie struct {
	Name     string `json:"name"`
	APIKey   string `json:"apiKey"`
	Region   string `json:"region"`
	Priority string `json:"priority"`
}

AlertChannelOpsgenie defines a type for an opsgenie alert channel

type AlertChannelPagerduty

type AlertChannelPagerduty struct {
	Account     string `json:"account,omitempty"`
	ServiceKey  string `json:"serviceKey"`
	ServiceName string `json:"serviceName,omitempty"`
}

AlertChannelPagerduty defines a type for an pager duty alert channel

type AlertChannelSMS

type AlertChannelSMS struct {
	Name   string `json:"name"`
	Number string `json:"number"`
}

AlertChannelSMS defines a type for a sms alert channel

type AlertChannelSlack

type AlertChannelSlack struct {
	WebhookURL string `json:"url"`
	Channel    string `json:"channel"`
}

AlertChannelSlack defines a type for a slack alert channel

type AlertChannelSubscription

type AlertChannelSubscription struct {
	ChannelID int64 `json:"alertChannelId"`
	Activated bool  `json:"activated"`
}

AlertChannelSubscription represents a subscription to an alert channel.

type AlertChannelWebhook

type AlertChannelWebhook struct {
	Name            string     `json:"name"`
	URL             string     `json:"url"`
	Method          string     `json:"method,omitempty"`
	Template        string     `json:"template,omitempty"`
	WebhookSecret   string     `json:"webhookSecret,omitempty"`
	Headers         []KeyValue `json:"headers,omitempty"`
	QueryParameters []KeyValue `json:"queryParameters,omitempty"`
}

AlertChannelWebhook defines a type for a webhook alert channel

type AlertSettings

type AlertSettings struct {
	EscalationType      string              `json:"escalationType,omitempty"`
	RunBasedEscalation  RunBasedEscalation  `json:"runBasedEscalation,omitempty"`
	TimeBasedEscalation TimeBasedEscalation `json:"timeBasedEscalation,omitempty"`
	Reminders           Reminders           `json:"reminders,omitempty"`
	SSLCertificates     SSLCertificates     `json:"sslCertificates,omitempty"`
}

AlertSettings represents an alert configuration.

type ApiCheckResult

type ApiCheckResult map[string]interface{}

ApiCheckResult represents an API Check result

type Assertion

type Assertion struct {
	Edit          bool   `json:"edit"`
	Order         int    `json:"order"`
	ArrayIndex    int    `json:"arrayIndex"`
	ArraySelector int    `json:"arraySelector"`
	Source        string `json:"source"`
	Property      string `json:"property"`
	Comparison    string `json:"comparison"`
	Target        string `json:"target"`
}

Assertion represents an assertion about an API response, which will be verified as part of the check.

type BasicAuth

type BasicAuth struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

BasicAuth represents the HTTP basic authentication credentials for a request.

type BrowserCheckResult

type BrowserCheckResult map[string]interface{}

BrowserCheckResult represents a Browser Check result

type Check

type Check struct {
	ID                        string                     `json:"id"`
	Name                      string                     `json:"name"`
	Type                      string                     `json:"checkType"`
	Frequency                 int                        `json:"frequency"`
	FrequencyOffset           int                        `json:"frequencyOffset,omitempty"`
	Activated                 bool                       `json:"activated"`
	Muted                     bool                       `json:"muted"`
	ShouldFail                bool                       `json:"shouldFail"`
	Locations                 []string                   `json:"locations,omitempty"`
	DegradedResponseTime      int                        `json:"degradedResponseTime"`
	MaxResponseTime           int                        `json:"maxResponseTime"`
	Script                    string                     `json:"script,omitempty"`
	EnvironmentVariables      []EnvironmentVariable      `json:"environmentVariables"`
	DoubleCheck               bool                       `json:"doubleCheck"`
	Tags                      []string                   `json:"tags,omitempty"`
	SSLCheck                  bool                       `json:"sslCheck"`
	SetupSnippetID            int64                      `json:"setupSnippetId,omitempty"`
	TearDownSnippetID         int64                      `json:"tearDownSnippetId,omitempty"`
	LocalSetupScript          string                     `json:"localSetupScript,omitempty"`
	LocalTearDownScript       string                     `json:"localTearDownScript,omitempty"`
	AlertSettings             AlertSettings              `json:"alertSettings,omitempty"`
	UseGlobalAlertSettings    bool                       `json:"useGlobalAlertSettings"`
	Request                   Request                    `json:"request"`
	GroupID                   int64                      `json:"groupId,omitempty"`
	GroupOrder                int                        `json:"groupOrder,omitempty"`
	AlertChannelSubscriptions []AlertChannelSubscription `json:"alertChannelSubscriptions,omitempty"`
	RuntimeID                 *string                    `json:"runtimeId"`
}

Check represents the parameters for an existing check.

type CheckResult

type CheckResult struct {
	ID                  string              `json:"id"`
	Name                string              `json:"name"`
	CheckID             string              `json:"checkId"`
	HasFailures         bool                `json:"hasFailures"`
	HasErrors           bool                `json:"hasErrors"`
	IsDegraded          bool                `json:"isDegraded"`
	OverMaxResponseTime bool                `json:"overMaxResponseTime"`
	RunLocation         string              `json:"runLocation"`
	StartedAt           time.Time           `json:"startedAt"`
	StoppedAt           time.Time           `json:"stoppedAt"`
	CreatedAt           time.Time           `json:"created_at"`
	ResponseTime        int64               `json:"responseTime"`
	ApiCheckResult      *ApiCheckResult     `json:"apiCheckResult"`
	BrowserCheckResult  *BrowserCheckResult `json:"browserCheckResult"`
	CheckRunID          int64               `json:"checkRunId"`
	Attempts            int64               `json:"attempts"`
}

CheckResult represents a Check result

type CheckResultsFilter

type CheckResultsFilter struct {
	Limit       int64
	Page        int64
	Location    string
	To          int64
	From        int64
	CheckType   CheckType
	HasFailures bool
}

CheckResultsFilter represents the parameters that can be passed while getting Check Results

type CheckType

type CheckType string

Check type constants

type Client

type Client interface {
	// Create creates a new check with the specified details.
	// It returns the newly-created check, or an error.
	Create(
		ctx context.Context,
		check Check,
	) (*Check, error)

	// Update updates an existing check with the specified details.
	// It returns the updated check, or an error.
	Update(
		ctx context.Context,
		ID string,
		check Check,
	) (*Check, error)

	// Delete deletes the check with the specified ID.
	Delete(
		ctx context.Context,
		ID string,
	) error

	// Get takes the ID of an existing check, and returns the check parameters,
	// or an error.
	Get(
		ctx context.Context,
		ID string,
	) (*Check, error)

	// CreateGroup creates a new check group with the specified details.
	// It returns the newly-created group, or an error.
	CreateGroup(
		ctx context.Context,
		group Group,
	) (*Group, error)

	// GetGroup takes the ID of an existing check group, and returns the
	// corresponding group, or an error.
	GetGroup(
		ctx context.Context,
		ID int64,
	) (*Group, error)

	// UpdateGroup takes the ID of an existing check group, and updates the
	// corresponding check group to match the supplied group. It returns the updated
	// group, or an error.
	UpdateGroup(
		ctx context.Context,
		ID int64,
		group Group,
	) (*Group, error)

	// DeleteGroup deletes the check group with the specified ID. It returns a
	DeleteGroup(
		ctx context.Context,
		ID int64,
	) error

	// GetCheckResult gets a specific Check result, or it returns an error.
	GetCheckResult(
		ctx context.Context,
		checkID,
		checkResultID string,
	) (*CheckResult, error)

	// GetCheckResults gets the results of the given Check
	GetCheckResults(
		ctx context.Context,
		checkID string,
		filters *CheckResultsFilter,
	) ([]CheckResult, error)

	// CreateSnippet creates a new snippet with the specified details. It returns
	// the newly-created snippet, or an error.
	CreateSnippet(
		ctx context.Context,
		snippet Snippet,
	) (*Snippet, error)

	// GetSnippet takes the ID of an existing snippet, and returns the
	// corresponding snippet, or an error.
	GetSnippet(
		ctx context.Context,
		ID int64,
	) (*Snippet, error)

	// UpdateSnippet takes the ID of an existing snippet, and updates the
	// corresponding snippet to match the supplied snippet. It returns the updated
	// snippet, or an error.
	UpdateSnippet(
		ctx context.Context,
		ID int64,
		snippet Snippet,
	) (*Snippet, error)

	// DeleteSnippet deletes the snippet with the specified ID. It returns a
	DeleteSnippet(
		ctx context.Context,
		ID int64,
	) error

	// CreateEnvironmentVariable creates a new environment variable with the
	// specified details.  It returns the newly-created environment variable,
	// or an error.
	CreateEnvironmentVariable(
		ctx context.Context,
		envVar EnvironmentVariable,
	) (*EnvironmentVariable, error)

	// GetEnvironmentVariable takes the ID of an existing environment variable, and returns the
	// corresponding environment variable, or an error.
	GetEnvironmentVariable(
		ctx context.Context,
		key string,
	) (*EnvironmentVariable, error)

	// UpdateEnvironmentVariable takes the ID of an existing environment variable, and updates the
	// corresponding environment variable to match the supplied environment variable. It returns the updated
	// environment variable, or an error.
	UpdateEnvironmentVariable(
		ctx context.Context,
		key string,
		envVar EnvironmentVariable,
	) (*EnvironmentVariable, error)

	// DeleteEnvironmentVariable deletes the environment variable with the specified ID. It returns a
	DeleteEnvironmentVariable(
		ctx context.Context,
		key string,
	) error

	// CreateAlertChannel creates a new alert channel with the specified details. It returns
	// the newly-created alert channel, or an error.
	CreateAlertChannel(
		ctx context.Context,
		ac AlertChannel,
	) (*AlertChannel, error)

	// GetAlertChannel takes the ID of an existing alert channel, and returns the
	// corresponding alert channel, or an error.
	GetAlertChannel(
		ctx context.Context,
		ID int64,
	) (*AlertChannel, error)

	// UpdateAlertChannel takes the ID of an existing alert channel, and updates the
	// corresponding alert channel to match the supplied alert channel. It returns the updated
	// alert channel, or an error.
	UpdateAlertChannel(
		ctx context.Context,
		ID int64,
		ac AlertChannel,
	) (*AlertChannel, error)

	// DeleteAlertChannel deletes the alert channel with the specified ID.
	DeleteAlertChannel(
		ctx context.Context,
		ID int64,
	) error

	// CreateDashboard creates a new dashboard with the specified details.
	CreateDashboard(
		ctx context.Context,
		dashboard Dashboard,
	) (*Dashboard, error)

	// GetDashboard takes the ID of an existing dashboard and returns it
	GetDashboard(
		ctx context.Context,
		ID string,
	) (*Dashboard, error)

	// UpdateDashboard takes the ID of an existing dashboard, and updates the
	// corresponding dashboard to match the supplied dashboard.
	UpdateDashboard(
		ctx context.Context,
		ID string,
		dashboard Dashboard,
	) (*Dashboard, error)

	// DeleteDashboard deletes the dashboard with the specified ID.
	DeleteDashboard(
		ctx context.Context,
		ID string,
	) error

	// CreateMaintenanceWindow creates a new maintenance window with the specified details.
	CreateMaintenanceWindow(
		ctx context.Context,
		mw MaintenanceWindow,
	) (*MaintenanceWindow, error)

	// GetMaintenanceWindow takes the ID of an existing maintennace window and returns it
	GetMaintenanceWindow(
		ctx context.Context,
		ID int64,
	) (*MaintenanceWindow, error)

	// UpdateMaintenanceWindow takes the ID of an existing maintenance window, and updates the
	// corresponding maintenance window to match the supplied maintenance window.
	UpdateMaintenanceWindow(
		ctx context.Context,
		ID int64,
		mw MaintenanceWindow,
	) (*MaintenanceWindow, error)

	// DeleteMaintenanceWindow deletes the maintenance window with the specified ID.
	DeleteMaintenanceWindow(
		ctx context.Context,
		ID int64,
	) error

	// CreateTriggerCheck creates a new trigger with the specified details.
	CreateTriggerCheck(
		ctx context.Context,
		checkID string,
	) (*TriggerCheck, error)

	// GetTriggerCheck takes the ID of an existing trigger and returns it
	GetTriggerCheck(
		ctx context.Context,
		checkID string,
	) (*TriggerCheck, error)

	// DeleteTriggerCheck deletes the trigger with the specified ID.
	DeleteTriggerCheck(
		ctx context.Context,
		checkID string,
	) error

	// CreateTriggerGroup creates a new trigger with the specified details.
	CreateTriggerGroup(
		ctx context.Context,
		groupID int64,
	) (*TriggerGroup, error)

	// GetTriggerGroup takes the ID of an existing trigger and returns it
	GetTriggerGroup(
		ctx context.Context,
		groupID int64,
	) (*TriggerGroup, error)

	// DeleteTriggerGroup deletes the trigger with the specified ID.
	DeleteTriggerGroup(
		ctx context.Context,
		groupID int64,
	) error

	// SetAccountId sets ID on a client which is required when using User API keys.
	SetAccountId(ID string)

	// SetChecklySource sets the source of the check for analytics purposes.
	SetChecklySource(source string)
}

Client is an interface that implements Checkly's API

func NewClient

func NewClient(

	baseURL,

	apiKey string,

	httpClient *http.Client,
	debug io.Writer,
) Client

NewClient constructs a Checkly API client.

type Dashboard

type Dashboard struct {
	ID             int64    `json:"id,omitempty"`
	DashboardID    string   `json:"dashboardId,omitempty"`
	CustomUrl      string   `json:"customUrl"`
	CustomDomain   string   `json:"customDomain"`
	Logo           string   `json:"logo"`
	Header         string   `json:"header"`
	Width          string   `json:"width,omitempty"`
	RefreshRate    int      `json:"refreshRate"`
	Paginate       bool     `json:"paginate"`
	PaginationRate int      `json:"paginationRate"`
	Tags           []string `json:"tags,omitempty"`
	HideTags       bool     `json:"hideTags"`
}

Dashboard defines a type for a dashboard.

type EnvironmentVariable

type EnvironmentVariable struct {
	Key    string `json:"key"`
	Value  string `json:"value"`
	Locked bool   `json:"locked"`
}

EnvironmentVariable represents a key-value pair for setting environment values during check execution.

type Group

type Group struct {
	ID                        int64                      `json:"id,omitempty"`
	Name                      string                     `json:"name"`
	Activated                 bool                       `json:"activated"`
	Muted                     bool                       `json:"muted"`
	Tags                      []string                   `json:"tags"`
	Locations                 []string                   `json:"locations"`
	Concurrency               int                        `json:"concurrency"`
	APICheckDefaults          APICheckDefaults           `json:"apiCheckDefaults"`
	EnvironmentVariables      []EnvironmentVariable      `json:"environmentVariables"`
	DoubleCheck               bool                       `json:"doubleCheck"`
	UseGlobalAlertSettings    bool                       `json:"useGlobalAlertSettings"`
	AlertSettings             AlertSettings              `json:"alertSettings,omitempty"`
	SetupSnippetID            int64                      `json:"setupSnippetId,omitempty"`
	TearDownSnippetID         int64                      `json:"tearDownSnippetId,omitempty"`
	LocalSetupScript          string                     `json:"localSetupScript,omitempty"`
	LocalTearDownScript       string                     `json:"localTearDownScript,omitempty"`
	AlertChannelSubscriptions []AlertChannelSubscription `json:"alertChannelSubscriptions,omitempty"`
	RuntimeID                 *string                    `json:"runtimeId"`
}

Group represents a check group.

type KeyValue

type KeyValue struct {
	Key    string `json:"key"`
	Value  string `json:"value"`
	Locked bool   `json:"locked"`
}

KeyValue represents a key-value pair, for example a request header setting, or a query parameter.

type MaintenanceWindow

type MaintenanceWindow struct {
	ID             int64    `json:"id"`
	Name           string   `json:"name"`
	StartsAt       string   `json:"startsAt"`
	EndsAt         string   `json:"endsAt"`
	RepeatInterval int      `json:"repeatInterval,omitempty"`
	RepeatUnit     string   `json:"repeatUnit"`
	RepeatEndsAt   string   `json:"repeatEndsAt,omitempty"`
	CreatedAt      string   `json:"created_at"`
	UpdatedAt      string   `json:"updated_at"`
	Tags           []string `json:"tags"`
}

MaintenanceWindow defines a type for a maintenance window.

type Reminders

type Reminders struct {
	Amount   int `json:"amount,omitempty"`
	Interval int `json:"interval,omitempty"`
}

Reminders represents the number of reminders to send after an alert notification, and the time interval between them.

type Request

type Request struct {
	Method          string      `json:"method"`
	URL             string      `json:"url"`
	FollowRedirects bool        `json:"followRedirects"`
	SkipSSL         bool        `json:"skipSSL"`
	Body            string      `json:"body"`
	BodyType        string      `json:"bodyType,omitempty"`
	Headers         []KeyValue  `json:"headers"`
	QueryParameters []KeyValue  `json:"queryParameters"`
	Assertions      []Assertion `json:"assertions"`
	BasicAuth       *BasicAuth  `json:"basicAuth,omitempty"`
}

Request represents the parameters for the request made by the check.

type RunBasedEscalation

type RunBasedEscalation struct {
	FailedRunThreshold int `json:"failedRunThreshold,omitempty"`
}

RunBasedEscalation represents an alert escalation based on a number of failed check runs.

type SSLCertificates

type SSLCertificates struct {
	Enabled        bool `json:"enabled"`
	AlertThreshold int  `json:"alertThreshold"`
}

SSLCertificates represents alert settings for expiring SSL certificates.

type Snippet

type Snippet struct {
	ID        int64     `json:"id"`
	Name      string    `json:"name"`
	Script    string    `json:"script"`
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
}

Snippet defines Snippet type

type TimeBasedEscalation

type TimeBasedEscalation struct {
	MinutesFailingThreshold int `json:"minutesFailingThreshold,omitempty"`
}

TimeBasedEscalation represents an alert escalation based on the number of minutes after a check first starts failing.

type TriggerCheck

type TriggerCheck struct {
	ID        int64  `json:"id,omitempty"`
	CheckId   string `json:"checkId,omitempty"`
	Token     string `json:"token"`
	URL       string `json:"url"`
	CreatedAt string `json:"created_at"`
	CalledAt  string `json:"called_at"`
	UpdatedAt string `json:"updated_at"`
}

Trigger defines a type for a check trigger.

type TriggerGroup

type TriggerGroup struct {
	ID        int64  `json:"id,omitempty"`
	GroupId   int64  `json:"groupId,omitempty"`
	Token     string `json:"token"`
	URL       string `json:"url"`
	CreatedAt string `json:"created_at"`
	CalledAt  string `json:"called_at"`
	UpdatedAt string `json:"updated_at"`
}

Trigger defines a type for a group trigger.