go-pingdom

README

go-pingdom

go-pingdom is a Go client library for the Pingdom API.

This currently supports working with HTTP, ping checks, and TCP checks.

Usage

Client

Construct a new Pingdom client:

client, err := pingdom.NewClientWithConfig(pingdom.ClientConfig{
    APIToken: "pingdom_api_token",
})

Using a Pingdom client, you can access supported services.

You can override the timeout or other parameters by passing a custom http client:

client, err := pingdom.NewClientWithConfig(pingdom.ClientConfig{
    APIToken: "pingdom_api_token",
    HTTPClient: &http.Client{
        Timeout: time.Second * 10,
    },
})

CheckService

This service manages pingdom Checks which are represented by the Check struct. When creating or updating Checks you must specify at a minimum the Name, Hostname and Resolution. Other fields are optional but if not set will be given the zero values for the underlying type.

More information on Checks from Pingdom: https://www.pingdom.com/features/api/documentation/#ResourceChecks

Get a list of all checks:

checks, err := client.Checks.List()
fmt.Println("Checks:", checks) // [{ID Name} ...]

Create a new HTTP check:

newCheck := pingdom.HttpCheck{Name: "Test Check", Hostname: "example.com", Resolution: 5}
check, err := client.Checks.Create(&newCheck)
fmt.Println("Created check:", check) // {ID, Name}

Create a new Ping check:

newCheck := pingdom.PingCheck{Name: "Test Check", Hostname: "example.com", Resolution: 5}
check, err := client.Checks.Create(&newCheck)
fmt.Println("Created check:", check) // {ID, Name}

Create a new TCP check:

newCheck := pingdom.TCPCheck{Name: "Test Check", Hostname: "example.com", Port: 25, StringToSend: "HELO foo.com", StringToExpect: "250 mail.test.com", Resolution: 5}
check, err := client.Checks.Create(&newCheck)
fmt.Println("Created check:", check) // {ID, Name}

Get details for a specific check:

checkDetails, err := client.Checks.Read(12345)

For checks with detailed information, check the specific details in the field Type (e.g. checkDetails.Type.HTTP).

Update a check:

updatedCheck := pingdom.HttpCheck{Name: "Updated Check", Hostname: "example2.com", Resolution: 5}
msg, err := client.Checks.Update(12345, &updatedCheck)

Delete a check:

msg, err := client.Checks.Delete(12345)

Create a check with basic alert notification to a user.

newCheck := pingdom.HttpCheck{Name: "Test Check", Hostname: "example.com", Resolution: 5, SendNotificationWhenDown: 2, UserIds []int{12345}}
checkResponse, err := client.Checks.Create(&newCheck)

MaintenanceService

This service manages pingdom Maintenances which are represented by the Maintenance struct. When creating or updating Maintenances you must specify at a minimum the Description, From and To. Other fields are optional but if not set will be given the zero values for the underlying type.

More information on Maintenances from Pingdom: https://www.pingdom.com/resources/api/2.1#ResourceMaintenance

Get a list of all maintenances:

maintenances, err := client.Maintenances.List()
fmt.Println("Maintenances:", maintenances) // [{ID Description} ...]

Create a new Maintenance Window:

m := pingdom.MaintenanceWindow{
    Description: "My Maintenance",
    From:        1,
    To:          1234567899,
}
maintenance, err := client.Maintenances.Create(&m)
fmt.Println("Created MaintenanceWindow:", maintenance) // {ID Description}

Get details for a specific maintenance:

maintenance, err := client.Maintenances.Read(12345)

Update a maintenance: (Please note, that based on experience, you are allowed to modify only Description, EffectiveTo and To)

updatedMaintenance := pingdom.MaintenanceWindow{
    Description: "My Maintenance",
    To:          1234567999,
}
msg, err := client.Maintenances.Update(12345, &updatedMaintenance)

Delete a maintenance:

Note: that only future maintenance window can be deleted. This means that both To and From should be in future.

msg, err := client.Maintenances.Delete(12345)

After contacting Pingdom, the better approach would be to use update function and setting To and EffectiveTo to current time

maintenance, _ := client.Maintenances.Read(12345)

m := pingdom.MaintenanceWindow{
    Description: maintenance.Description,
    From:        maintenance.From,
    To:          1,
    EffectiveTo: 1,
}

maintenanceUpdate, err := client.Maintenances.Update(12345, &m)

ProbeService

This service gets pingdom Probes which are represented by the Probes struct.

More information on Probes from Pingdom: https://www.pingdom.com/resources/api/2.1#ResourceProbes Several parameters are supported for filtering output. Please see them in Pingdom API documentation.

NOTE: Official documentation does not specify that region is returned for every probe entry, but it does and you can use it.

Get a list of all probes:

params := make(map[string]string)

probes, err := client.Probes.List(params)
fmt.Println("Probes:", probes) // [{ID Name} ...]

for _, probe := range probes {
    fmt.Println("Probe region:", probe.Region)  // Probe region: EU
}

Development

Acceptance Tests

You can run acceptance tests against the actual pingdom API to test any changes:

PINGDOM_API_TOKEN=[api token] make acceptance

Note that this will create actual resources in your Pingdom account. The tests will make a best effort to clean up but these would not be guaranteed on test failures depending on the nature of the failure.