OpsGenie Go API

The OpsGenie SDK for Go provides a set of Go API for OpsGenie services, making it easier for go developers to build applications that integrate with OpsGenie. Developers can build Go applications on top of APIs that take the complexity out of coding directly against a web service interface. The library provides APIs that hide much of the lower-level plumbing, including authentication, request retries, and error handling.

Before you can begin, you must sign up for OpsGenie service, create an API Integration and get your API key. In order to use the OpsGenie Go SDK, you will need the API key from the API Integration you created. The API key is used to authenticate requests to the service and identify yourself as the sender of a request.

Go SDK Installation

Golang SDK requires Go version 1.4.1 or above. Golang can be downloaded here. One should make sure the GOPATH and GOROOT variables are set accordingly. Following that the API source can be downloaded via command go get github.com/opsgenie/opsgenie-go-sdk/.... The command will automatically download and install necessary package files and dependencies under the src directory of the GOPATH.

OpsGenie Go Sdk source code is available at GitHub OpsGenie Go Sdk repository.

Client Initialization

There are packages required to interact with the API. Client packages is required to use All APIs. Alert, Heartbeat, Integration and Policy packages should be added according to the requirement.

  import (
      alerts "github.com/opsgenie/opsgenie-go-sdk/alertsv2"
      ogcli "github.com/opsgenie/opsgenie-go-sdk/client"
      "github.com/opsgenie/opsgenie-go-sdk/heartbeat"
      "github.com/opsgenie/opsgenie-go-sdk/integration"
      "github.com/opsgenie/opsgenie-go-sdk/policy"
  )

Client is the basic data structure on which all operations and actions are taken. A client variable can be created as following.

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key here")

It is required to set the API key before going on subsequent calls. Otherwise the authentication will fail and the API is going to raise an exception.


Connection Configuration

Proxy Configuration

Users can set the enlisted parameters if they would like to connect through a proxy server.
  • Username
  • Password
  • Host IP/name
  • Port number
  • Protocol i.e. https or http.
The configuration is achieved via setting a proxy data structure with the above given parameters and client. Here is an example of how to configure the OpsGenieClient.
  cli := new (ogcli.OpsGenieClient)
  // OpsGenie client proxy configuration
  pc := new (ogcli.ClientProxyConfiguration)
  pc.Host = "proxy.example.com"
  pc.Port = 8080
  pc.Username = "user"
  pc.Password = "secret"
  pc.Protocol = "http"
  // set the proxy configuration
  cli.SetClientProxyConfiguration( pc )

Http Transport Layer Configuration

It is also possible to modify a few Http transport layer settings. They include:
  • Connection timeout
  • Request timeout
  • Maximum number of retries when the requests fallback

Connection timeout is the value in seconds that the client tries to connect to the server. Request timeout is total time of the request, including connection time. Hence, it should be configured longer than connection timeout.

  cli := new (ogcli.OpsGenieClient)
  // HttpTransportSettings
  cfg := new (ogcli.HttpTransportSettings)
  cfg.ConnectionTimeout = 2   // in seconds
  cfg.RequestTimeout = 5   // in seconds
  cfg.MaxRetryAttempts = 5

  cli.SetHttpTransportSettings( cfg )

Exception Handling

OpsGenie Go SDK, has many functions usually return two values. One of the values is a pointer to an error value. Errors are the way to check if the performing operation is completed successfully.
  resp, err := alertClient.Get( alertRequest )
  // check if error
  if err != nil {
      // you have now an error message accessible via err.Error()
  }

Alert API

Import Sstatements

import (
    alerts "github.com/opsgenie/opsgenie-go-sdk/alertsv2"
    ogcli "github.com/opsgenie/opsgenie-go-sdk/client"
)
    

Create Alert

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  teams := []alerts.TeamRecipient{
      &alerts.Team{Name: "teamId"},
      &alerts.Team{ID: "teamId"},
  }

  visibleTo := [] alerts.Recipient{
      &alerts.Team{ID: "teamId"},
      &alerts.Team{Name: "teamName"},
      &alerts.User{ID: "userId"},
      &alerts.User{Username: "user@opsgenie.com"},
  }

  request := alerts.CreateAlertRequest{
      Message:     "message",
      Alias:       "alias",
      Description: "alert description",
      Teams:       teams,
      VisibleTo:   visibleTo,
      Actions:     []string{"action1", "action2"},
      Tags:        []string{"tag1", "tag2"},
      Details: map[string]string{
          "key":  "value",
          "key2": "value2",
      },
      Entity:   "entity",
      Source:   "source",
      Priority: alerts.P1,
      User:     "user@opsgenie.com",
      Note:     "alert note",
  }

  response, err := alertCli.Create(request)
  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("Create request ID: " + response.RequestID)
  }
  

Close Alert

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  identifier := alerts.Identifier{
      TinyID: "2",
  };
  closeRequest := alerts.CloseRequest{
      Identifier: &identifier,
      User:       "test",
      Source:     "Source",
      Note:       "Note",
  }

  response, err := alertCli.Close(closeRequest)

  if err != nil {
      panic(err)
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Delete Alert

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.DeleteAlertRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      Source: "source",
      User:   "user@opsgenie.com",
  }

  response, err := alertCli.Delete(request)

  if err != nil {
      panic(err)
  } else {
      fmt.Println("RequestID:" + response.RequestID)
  }

Get Alert

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  response, err := alertCli.Get(alerts.GetAlertRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
  })

  if err != nil {
      panic(err)
  } else {
      alert := response.Alert
      fmt.Printf("ID: %s\n",  alert.ID)
      fmt.Printf("Message: %s\n",  alert.Message)
      fmt.Printf("Tags: %v\n",  alert.Tags)
      fmt.Printf("Count: %d\n",  alert.Count)
      fmt.Printf("Tiny: %s\n",  alert.TinyID)
  }

List Alerts

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  response, err := alertCli.List(alerts.ListAlertRequest{
      Limit:                5,
      Offset:               0,
      SearchIdentifierType: alerts.Name,
  })

  if err != nil {
      panic(err)
  } else {
      for i, alert := range response.Alerts {
          fmt.Println(strconv.Itoa(i) + ". " + alert.Message)
      }
  }

List Alert Notes

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.ListAlertNotesRequest{
      Identifier: &alerts.Identifier{
         TinyID: "2",
      },
      Order:     "asc",
      Direction: alerts.Next,
      Offset:    "1",
      Limit:     2,
  }
  response, err := alertCli.ListAlertNotes(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      for _, note := range response.AlertNotes {
          fmt.Println(note.Note)
      }
  }

List Alert Logs

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.ListAlertLogsRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      Order:     "asc",
      Direction: alerts.Next,
      Offset:    "0",
      Limit:     5,
  }

  response, err := alertCli.ListAlertLogs(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      for _, log := range response.AlertLogs {
          fmt.Println(log.Log + " [" + log.Type + "]")
      }
  }

List Alert Recipients

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.ListAlertRecipientsRequest{
      Identifier: &alerts.Identifier{
         TinyID: "2",
      },
  }

  response, err := alertCli.ListAlertRecipients(request)

  if err != nil {
        panic(err)
  } else {
      for i, recipient := range response.Recipients {
          fmt.Println(strconv.Itoa(i) + ". " + recipient.User.Username + " : " + recipient.State)
      }
  }

Acknowledge

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  identifier := alerts.Identifier{
      TinyID: "2",
  };
  ackRequest := alerts.AcknowledgeRequest{
      Identifier: &identifier,
      User:       "test",
      Source:     "Source",
      Note:       "Note",
  }

  response, err := alertCli.Acknowledge(ackRequest)

  if err != nil {
      fmt.Print(err.Error())
  } else {
      fmt.Println("RequestId: " + response.RequestID)
  }

Unacknowledge

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  identifier := alerts.Identifier{
      TinyID: "2",
  };

  unackRequest := alerts.UnacknowledgeRequest{
      Identifier: &identifier,
      User:       "test",
      Source:     "Source",
      Note:       "Note",
  }

  response, _ := alertCli.Unacknowledge(unackRequest)
  fmt.Println("RequestID: " + response.RequestID)

Snooze

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  identifier := alerts.Identifier{
      TinyID: "2",
  };

  actionRequest := alerts.AlertActionRequest{
      Identifier: &identifier,
      User:       "test",
      Source:     "Source",
      Note:       "Note",
  }

  ackRequest := alerts.SnoozeRequest{
      AlertActionRequest: actionRequest,
      EndTime: time.Now().AddDate(0, 0, 1)
  }

  response, err := alertCli.Snooze(ackRequest)

  if err != nil {
      panic(err)
  } else {
      fmt.Println("RequsetId: " + response.RequestID)
  }

Assign Owner

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.AssignAlertRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
    },
  User:   "test",
  Source: "Source",
  Note:   "Note",
  Owner: alerts.User{
        Username: "user@opsgenie.com",
      },
  }
  response, err := alertCli.Assign(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Add Team

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.AddTeamToAlertRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      User:   "test",
      Source: "Source",
      Note:   "Note",
      Team: alerts.Team{
          Name:   "team_name",
      },
  }
  response, err := alertCli.AddTeamToAlert(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Add Note

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.AddNoteRequest{
      Identifier: &alerts.Identifier{
         TinyID: "2",
      },
      User:   "test",
      Source: "Source",
      Note:   "Note",
  }

  response, err := alertCli.AddNote(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Add Tags

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.AddTagsToAlertRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      User:   "test",
      Source: "Source",
      Note:   "Note",
      Tags:   []string{"tag1", "tag2"},
  }
  response, err := alertCli.AddTags(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Remove Tags

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.RemoveTagsRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      User:   "test",
      Source: "Source",
      Note:   "Note",
      Tags:   []string{"tag1"},
  }
  response, err := alertCli.RemoveTags(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Add Details

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.AddDetailsRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      User:   "test",
      Source: "Source",
      Note:   "Note",
      Details: map[string]string{
          "key1": "value1",
          "key2": "value2",
      },
  }
  response, err := alertCli.AddDetails(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Remove Details

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.RemoveDetailsRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      User:   "test",
      Source: "Source",
      Note:   "Note",
      Keys:   [] string{"key2"},
  }
  response, err := alertCli.RemoveDetails(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Execute Action

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  identifier := alerts.Identifier{
      TinyID: "2",
  };

  response, err := alertCli.ExecuteCustomAction(alerts.ExecuteCustomActionRequest{
      Identifier: &identifier,
      User:       "test",
      Source:     "Source",
      Note:       "Note",
      ActionName: "customActionNew",
  })

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestID: " + response.RequestID)
  }

Escalate To Next

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  alertCli, _ := cli.AlertV2()

  request := alerts.EscalateToNextRequest{
      Identifier: &alerts.Identifier{
          TinyID: "2",
      },
      User:   "test",
      Source: "Source",
      Note:   "Note",
      Escalation: alerts.Escalation{
        Name: "escalationName",
      },
  }
  response, err := alertCli.EscalateToNext(request)

  if err != nil {
      fmt.Println(err.Error())
  } else {
      fmt.Println("RequestId: " + response.RequestID)
  }

Heartbeat API

Import Statements

  import (
      hb "github.com/opsgenie/opsgenie-go-sdk/heartbeat"
      ogcli "github.com/opsgenie/opsgenie-go-sdk/client"
  )
 

Add Heartbeat

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
      panic(cliErr)
  }

  // create the hb
  req := hb.AddHeartbeatRequest{Name: "name of the heartbeat" }
  response, hbErr := hbCli.Add(req)

  if hbErr != nil {
      panic(hbErr)
  }

  fmt.Printf("name: %s\n",    response.Name)
  fmt.Printf("status: %s\n",  response.Status)
  fmt.Printf("code: %d\n",  response.Code)
 

Update Heartbeat

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
      panic(cliErr)
  }

  // update
  updateReq := hb.UpdateHeartbeatRequest{
          Name: "heartbeat name",
          Description: "updated description",
          }
  updateResp, updateErr := hbCli.Update(updateReq)

  if updateErr != nil {
      panic(updateErr)
  }

  fmt.Printf("name: %s\n",    updateResp.Name)
  fmt.Printf("status: %s\n",  updateResp.Status)
  fmt.Printf("code: %d\n",  updateResp.Code)

Enable Heartbeat

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
      panic(cliErr)
  }
  // enable the hb
  enableReq := hb.EnableHeartbeatRequest{Name: "heartbeat name"}
  enableResp, enableErr := hbCli.Enable( enableReq )

  if enableErr != nil {
      panic(enableErr)
  }

  fmt.Printf("Status: %s\n",  enableResp.Status)
  fmt.Printf("Code: %d\n",    enableResp.Code)

Disable Heartbeat

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
      panic(cliErr)
  }
  // disable
  disableReq := hb.DisableHeartbeatRequest{Name: "heartbeat name"}
  disableResp, disableErr := hbCli.Disable( disableReq )

  if disableErr != nil {
      panic(disableErr)
  }

  fmt.Printf("Status: %s\n",  disableResp.Status)
  fmt.Printf("Code: %d\n",    disableResp.Code)

Delete Heartbeat

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
      panic(cliErr)
  }
  // delete the hb
  deleteReq := hb.DeleteHeartbeatRequest{Name: "heartbeat name}
  deleteResp, deleteErr := hbCli.Delete( deleteReq )

  if deleteErr != nil {
      panic(deleteErr)
  }

  fmt.Printf("Status: %s\n",  deleteResp.Status)
  fmt.Printf("Code: %d\n",    deleteResp.Code)

Get Heartbeat

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
     panic(cliErr)
  }

  // get the heartbeat
  getReq := hb.GetHeartbeatRequest{Name: "heartbeat name"}
  getResp, getErr := hbCli.Get( getReq )

  if getErr != nil {
      panic(getErr)
  }

  fmt.Printf("Name: %s\n", getResp.Name)
  fmt.Printf("Status: %s\n", getResp.Status)
  fmt.Printf("Description: %s\n", getResp.Description)
  fmt.Printf("Enabled?: %t\n", getResp.Enabled)
  fmt.Printf("Last Heartbeat: %d\n", getResp.LastHeartbeat)
  fmt.Printf("Interval: %d\n", getResp.Interval)
  fmt.Printf("Interval Unit: %s\n", getResp.IntervalUnit)
  fmt.Printf("Expired?: %t\n", getResp.Expired)

List Heartbeats

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
      panic(cliErr)
  }
  // list the HBs
  listReq := hb.ListHeartbeatsRequest{}
  listResp, listErr := hbCli.List(listReq)

  if listErr != nil {
     panic(listErr)
  }

  beats := listResp.Heartbeats
  for _, beat := range beats {
      fmt.Printf("Name: %s\n", beat.Name)
      fmt.Printf("Status %s\n", beat.Status)
      fmt.Printf("Description: %s\n", beat.Description)
      fmt.Printf("Enabled?: %t\n", beat.Enabled)
      fmt.Printf("Last Heartbeat: %d\n", beat.LastHeartbeat)
      fmt.Printf("Interval: %d\n", beat.Interval)
      fmt.Printf("Interval Unit: %s\n", beat.IntervalUnit)
      fmt.Printf("Expired?: %t\n", beat.Expired)
  }

Send Heartbeat (Ping)

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  hbCli, cliErr := cli.Heartbeat()

  if cliErr != nil {
      panic(cliErr)
  }


  // send heart beat request
  pingRequest := hb.PingHeartbeatRequest{Name: "heeartbeat name"}
  pingResponse, sendErr := hbCli.Ping(pingRequest)

  if sendErr != nil {
      panic(sendErr)
  }

  fmt.Println()
  fmt.Printf("Heartbeat request sent\n")
  fmt.Printf("----------------------\n")
  fmt.Printf("RequestId: %s\n", pingResponse.RequestID)
  fmt.Printf("Response Time: %f\n", pingResponse.ResponseTime)

Policy API

Import Sstatements

  import(
      policy "github.com/opsgenie/opsgenie-go-sdk/policy"
      ogcli "github.com/opsgenie/opsgenie-go-sdk/client"
  )

Enable Policy

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")
  polCli, cliErr := cli.Policy()

  if cliErr != nil {
     panic(cliErr)
  }
  // enable the policy
  req := policy.EnablePolicyRequest{Name: "policy name"}

  _, err = polCli.Enable(req)

  if err != nil {
      panic(err)
  } else {
      fmt.Printf("Policy enabled successfully")
  }

Disable Policy

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")
  polCli, cliErr := cli.Policy()

  if cliErr != nil {
     panic(cliErr)
  }
  // enable the policy
  req := policy.DisablePolicyRequest{Name: "policy name"}

  _, err = polCli.Disable(req)

  if err != nil {
      panic(err)
  } else {
      fmt.Printf("Policy disabled successfully")
  }

Contact API

Import statements

  import (
      hb "github.com/opsgenie/opsgenie-go-sdk/contact"
      ogcli "github.com/opsgenie/opsgenie-go-sdk/client"
  )

Create Contact

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  contactCli, cliErr := cli.Contact()
  if cliErr != nil {
      panic(cliErr)
  }

  contactReq := contacts.CreateContactRequest{ Method: "method name", To: "to", Username: "username"}

  contactResp, contactErr := contactCli.Create(contactReq)
  if contactErr != nil {
      panic(contactErr)
  }

  fmt.Printf("id: %s\n", contactResp.Id)
  fmt.Printf("status: %s\n", contactResp.Status)
  fmt.Printf("code: %d\n", contactResp.Code)

Delete Contact

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  contactCli, cliErr := cli.Contact()
  if cliErr != nil {
     panic(cliErr)
  }

  contactReq := contacts.CreateContactRequest{ Method: "method name", To: "to", Username: "username"}

  contactResp, contactErr := contactCli.Create(contactReq)
  if contactErr != nil {
     panic(contactErr)
  }

  contactDeleteReq := contacts.DeleteContactRequest{ Id: contactResp.Id, Username: "username"}
  contactDeleteResp, contactDeleteErr := contactCli.Delete(contactDeleteReq)
  if contactDeleteErr != nil {
      panic(contactDeleteErr)
  }

  fmt.Printf("status: %s\n", contactDeleteResp.Status)
  fmt.Printf("code: %d\n", contactDeleteResp.Code)

Get Contact

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  contactCli, cliErr := cli.Contact()
  if cliErr != nil {
      panic(cliErr)
  }

  contactReq := contacts.CreateContactRequest{ Method: "method name", To: "to", Username: "username"}

  contactResp, contactErr := contactCli.Create(contactReq)
  if contactErr != nil {
      panic(contactErr)
  }

  contactGetReq := contacts.GetContactRequest{ Id: contactResp.Id, Username: "username"}
  contactGetResp, contactGetErr := contactCli.Get(contactGetReq)
  if contactGetErr != nil {
      panic(contactGetErr)
  }

  fmt.Printf("disabledReason: %s\n", contactGetResp.DisabledReason)
  fmt.Printf("method: %s\n", contactGetResp.Method)
  fmt.Printf("to: %s\n", contactGetResp.To)
  fmt.Printf("id: %s\n", contactGetResp.Id)
  fmt.Printf("enabled: %t\n", contactGetResp.Enabled)

Enable Contact

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  contactCli, cliErr := cli.Contact()
  if cliErr != nil {
      panic(cliErr)
  }

  contactReq := contacts.CreateContactRequest{ Method: "method name", To: "to", Username: "username"}

  contactResp, contactErr := contactCli.Create(contactReq)
  if contactErr != nil {
      panic(contactErr)
  }

  contactEnableReq := contacts.EnableContactRequest{ Id: contactResp.Id, Username: "username"}
  contactEnableResp, contactEnableErr := contactCli.Enable(contactEnableReq)
  if contactEnableErr != nil {
     panic(contactEnableErr)
  }

  fmt.Printf("status: %s\n", contactEnableResp.Status)

Disable Contact

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  contactCli, cliErr := cli.Contact()
  if cliErr != nil {
     panic(cliErr)
  }

  contactReq := contacts.CreateContactRequest{ Method: "method name", To: "to", Username: "username"}

  contactResp, contactErr := contactCli.Create(contactReq)
  if contactErr != nil {
      panic(contactErr)
  }

  contactDisableReq := contacts.DisableContactRequest{ Id: contactResp.Id, Username: "username"}
  contactDisableResp, contactDisableErr := contactCli.Disable(contactDisableReq)
  if contactDisableErr != nil {
      panic(contactDisableErr)
  }

  fmt.Printf("status: %s\n", contactDisableResp.Status)

Update Contact

  cli := new(ogcli.OpsGenieClient)
  cli.SetAPIKey("your OpsGenie api key")

  contactCli, cliErr := cli.Contact()
  if cliErr != nil {
     panic(cliErr)
  }

  contactReq := contacts.CreateContactRequest{ Method: "method name", To: "to", Username: "username"}

  contactResp, contactErr := contactCli.Create(contactReq)
  if contactErr != nil {
      panic(contactErr)
  }

  contactUpdateReq := contacts.UpdateContactRequest{ Username: "username", Id: contactResp.Id, To: "to"}
  contactUpdateResp, contactUpdateErr := contactCli.Update(contactUpdateReq)
  if contactUpdateErr != nil {
      panic(contactUpdateErr)
  }

  fmt.Printf("id: %s\n", contactUpdateResp.Id)
  fmt.Printf("status: %s\n", contactUpdateResp.Status)
  fmt.Printf("code: %d\n", contactUpdateResp.Code)

Integration API

Import Statements

  import(
      integration "github.com/opsgenie/opsgenie-go-sdk/integration"
      ogcli "github.com/opsgenie/opsgenie-go-sdk/client"
  )

Enable Integration

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey(apiKey)
  intCli, cliErr := cli.Integration()

  if cliErr != nil {
      panic(cliErr)
  }

  // enable the integration
  req := integration.EnableIntegrationRequest{Name: "integration name"}

  _, err = intCli.Enable(req)

  if err != nil {
      panic(err)
  } else {
     fmt.Printf("Integration enabled successfully")
  }

Disable Integration

  cli := new (ogcli.OpsGenieClient)
  cli.SetAPIKey(apiKey)
  intCli, cliErr := cli.Integration()

  if cliErr != nil {
      panic(cliErr)
  }

  // enable the integration
  req := integration.DisableIntegrationRequest{Name: "integration name"}

  _, err = intCli.Disable(req)

  if err != nil {
      panic(err)
  } else {
      fmt.Printf("Integration disabled successfully")
  }