CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/golang-github-com-data-dog--datadog-api-client-go-v2

Comprehensive Go API client for the Datadog monitoring and analytics platform with strongly-typed interfaces for all Datadog API v1 and v2 endpoints

Overview
Eval results
Files

logs-metrics-events.mddocs/v1/

V1 Logs, Metrics, and Events APIs

Log ingestion and querying, metric submission, and event management in API v1.

Package Import

import (
    "context"
    "github.com/DataDog/datadog-api-client-go/v2/api/datadog"
    "github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
)

Logs API

Submit and query logs.

API Client

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

func NewLogsApi(client *datadog.APIClient) *LogsApi

Methods

func (a *LogsApi) ListLogs(
    ctx context.Context,
    body datadogV1.LogsListRequest,
) (datadogV1.LogsListResponse, *http.Response, error)

Query logs.

func (a *LogsApi) SubmitLog(
    ctx context.Context,
    body []datadogV1.HTTPLogItem,
    o ...SubmitLogOptionalParameters,
) (interface{}, *http.Response, error)

Submit log entries.

Optional Parameters

type SubmitLogOptionalParameters struct {
    ContentEncoding *datadogV1.ContentEncoding
    Ddtags          *string
}

Key Types

type HTTPLogItem struct {
    Ddsource  *string
    Ddtags    *string
    Hostname  *string
    Message   string
    Service   *string
}

func NewHTTPLogItem(message string) *HTTPLogItem

Example Usage

// Submit logs
logItem := datadogV1.NewHTTPLogItem("Application started successfully")
logItem.SetService("my-app")
logItem.SetHostname("web-server-01")
logItem.SetDdsource("golang")

optionalParams := datadogV1.NewSubmitLogOptionalParameters()
_, r, err := logsApi.SubmitLog(ctx, []datadogV1.HTTPLogItem{*logItem}, *optionalParams)
if err != nil {
    fmt.Fprintf(os.Stderr, "Error submitting log: %v\n", err)
    return
}

fmt.Println("Log submitted successfully")

Logs Indexes API

Manage log indexes for data retention and filtering.

API Client

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

func NewLogsIndexesApi(client *datadog.APIClient) *LogsIndexesApi

Methods

func (a *LogsIndexesApi) CreateLogsIndex(
    ctx context.Context,
    body datadogV1.LogsIndex,
) (datadogV1.LogsIndex, *http.Response, error)
func (a *LogsIndexesApi) DeleteLogsIndex(
    ctx context.Context,
    name string,
) (*http.Response, error)
func (a *LogsIndexesApi) GetLogsIndex(
    ctx context.Context,
    name string,
) (datadogV1.LogsIndex, *http.Response, error)
func (a *LogsIndexesApi) GetLogsIndexOrder(
    ctx context.Context,
) (datadogV1.LogsIndexesOrder, *http.Response, error)
func (a *LogsIndexesApi) ListLogIndexes(
    ctx context.Context,
) (datadogV1.LogsIndexListResponse, *http.Response, error)
func (a *LogsIndexesApi) UpdateLogsIndex(
    ctx context.Context,
    name string,
    body datadogV1.LogsIndexUpdateRequest,
) (datadogV1.LogsIndex, *http.Response, error)
func (a *LogsIndexesApi) UpdateLogsIndexOrder(
    ctx context.Context,
    body datadogV1.LogsIndexesOrder,
) (datadogV1.LogsIndexesOrder, *http.Response, error)

Logs Pipelines API

Configure log processing pipelines.

API Client

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

func NewLogsPipelinesApi(client *datadog.APIClient) *LogsPipelinesApi

Methods

func (a *LogsPipelinesApi) CreateLogsPipeline(
    ctx context.Context,
    body datadogV1.LogsPipeline,
) (datadogV1.LogsPipeline, *http.Response, error)
func (a *LogsPipelinesApi) DeleteLogsPipeline(
    ctx context.Context,
    pipelineId string,
) (*http.Response, error)
func (a *LogsPipelinesApi) GetLogsPipeline(
    ctx context.Context,
    pipelineId string,
) (datadogV1.LogsPipeline, *http.Response, error)
func (a *LogsPipelinesApi) GetLogsPipelineOrder(
    ctx context.Context,
) (datadogV1.LogsPipelinesOrder, *http.Response, error)
func (a *LogsPipelinesApi) ListLogsPipelines(
    ctx context.Context,
) ([]datadogV1.LogsPipeline, *http.Response, error)
func (a *LogsPipelinesApi) UpdateLogsPipeline(
    ctx context.Context,
    pipelineId string,
    body datadogV1.LogsPipeline,
) (datadogV1.LogsPipeline, *http.Response, error)
func (a *LogsPipelinesApi) UpdateLogsPipelineOrder(
    ctx context.Context,
    body datadogV1.LogsPipelinesOrder,
) (datadogV1.LogsPipelinesOrder, *http.Response, error)

Metrics API

Submit and query metrics.

API Client

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

func NewMetricsApi(client *datadog.APIClient) *MetricsApi

Methods

func (a *MetricsApi) GetMetricMetadata(
    ctx context.Context,
    metricName string,
) (datadogV1.MetricMetadata, *http.Response, error)

Get metadata for a metric.

func (a *MetricsApi) ListActiveMetrics(
    ctx context.Context,
    from int64,
    o ...ListActiveMetricsOptionalParameters,
) (datadogV1.MetricsListResponse, *http.Response, error)

List active metrics.

func (a *MetricsApi) ListMetrics(
    ctx context.Context,
    q string,
) (datadogV1.MetricSearchResponse, *http.Response, error)

Search metrics by name.

func (a *MetricsApi) QueryMetrics(
    ctx context.Context,
    from int64,
    to int64,
    query string,
) (datadogV1.MetricsQueryResponse, *http.Response, error)

Query timeseries data.

func (a *MetricsApi) SubmitDistributionPoints(
    ctx context.Context,
    body datadogV1.DistributionPointsPayload,
    o ...SubmitDistributionPointsOptionalParameters,
) (datadogV1.IntakePayloadAccepted, *http.Response, error)

Submit distribution points.

func (a *MetricsApi) SubmitMetrics(
    ctx context.Context,
    body datadogV1.MetricsPayload,
    o ...SubmitMetricsOptionalParameters,
) (datadogV1.IntakePayloadAccepted, *http.Response, error)

Submit metric points.

func (a *MetricsApi) UpdateMetricMetadata(
    ctx context.Context,
    metricName string,
    body datadogV1.MetricMetadata,
) (datadogV1.MetricMetadata, *http.Response, error)

Update metric metadata.

Optional Parameters

type ListActiveMetricsOptionalParameters struct {
    Host            *string
    TagFilter       *string
}

type SubmitDistributionPointsOptionalParameters struct {
    ContentEncoding *datadogV1.DistributionPointsContentEncoding
}

type SubmitMetricsOptionalParameters struct {
    ContentEncoding *datadogV1.MetricContentEncoding
}

Key Types

type MetricsPayload struct {
    Series []Series
}

func NewMetricsPayload(series []Series) *MetricsPayload
type Series struct {
    Host     *string
    Interval *int64
    Metric   string
    Points   [][]*float64
    Tags     []string
    Type     *string
}

func NewSeries(metric string) *Series

Example Usage

// Submit metrics
now := time.Now().Unix()
series := datadogV1.NewSeries("my.custom.metric")
series.SetType("gauge")
series.SetPoints([][]*float64{
    {datadog.PtrFloat64(float64(now)), datadog.PtrFloat64(42.0)},
})
series.SetTags([]string{"env:production", "service:api"})

payload := datadogV1.NewMetricsPayload([]datadogV1.Series{*series})
optionalParams := datadogV1.NewSubmitMetricsOptionalParameters()

resp, r, err := metricsApi.SubmitMetrics(ctx, *payload, *optionalParams)
if err != nil {
    fmt.Fprintf(os.Stderr, "Error submitting metrics: %v\n", err)
    return
}

fmt.Printf("Metrics submitted: %s\n", resp.GetStatus())

// Query metrics
from := time.Now().Add(-1 * time.Hour).Unix()
to := time.Now().Unix()
query := "avg:my.custom.metric{*}"

queryResp, r, err := metricsApi.QueryMetrics(ctx, from, to, query)
if err != nil {
    fmt.Fprintf(os.Stderr, "Error querying metrics: %v\n", err)
    return
}

fmt.Printf("Query result: %+v\n", queryResp)

Events API

Create and query events.

API Client

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

func NewEventsApi(client *datadog.APIClient) *EventsApi

Methods

func (a *EventsApi) CreateEvent(
    ctx context.Context,
    body datadogV1.EventCreateRequest,
) (datadogV1.EventCreateResponse, *http.Response, error)

Create an event.

func (a *EventsApi) GetEvent(
    ctx context.Context,
    eventId int64,
) (datadogV1.EventResponse, *http.Response, error)

Get an event's details.

func (a *EventsApi) ListEvents(
    ctx context.Context,
    start int64,
    end int64,
    o ...ListEventsOptionalParameters,
) (datadogV1.EventListResponse, *http.Response, error)

List events in a time range.

Optional Parameters

type ListEventsOptionalParameters struct {
    Priority       *datadogV1.EventPriority
    Sources        *string
    Tags           *string
    Unaggregated   *bool
    ExcludeAggregate *bool
    Page           *int32
}

Key Types

type EventCreateRequest struct {
    AggregationKey *string
    AlertType      *datadogV1.EventAlertType
    DateHappened   *int64
    DeviceName     *string
    Host           *string
    Priority       NullableEventPriority
    RelatedEventId *int64
    SourceTypeName *string
    Tags           []string
    Text           string
    Title          string
}

func NewEventCreateRequest(text string, title string) *EventCreateRequest

Example Usage

// Create an event
event := datadogV1.NewEventCreateRequest(
    "Deployment completed successfully",
    "Production Deployment",
)
event.SetTags([]string{"deployment", "production", "version:2.1.0"})
event.SetAlertType(datadogV1.EVENTALERTTYPE_INFO)

resp, r, err := eventsApi.CreateEvent(ctx, *event)
if err != nil {
    fmt.Fprintf(os.Stderr, "Error creating event: %v\n", err)
    return
}

fmt.Printf("Event created: ID %d\n", resp.Event.GetId())

// List recent events
start := time.Now().Add(-24 * time.Hour).Unix()
end := time.Now().Unix()
optionalParams := datadogV1.NewListEventsOptionalParameters()
optionalParams.WithTags("deployment")

listResp, r, err := eventsApi.ListEvents(ctx, start, end, *optionalParams)
if err != nil {
    fmt.Fprintf(os.Stderr, "Error listing events: %v\n", err)
    return
}

fmt.Printf("Found %d events\n", len(listResp.GetEvents()))

Service Checks API

Submit service check statuses.

API Client

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

func NewServiceChecksApi(client *datadog.APIClient) *ServiceChecksApi

Methods

func (a *ServiceChecksApi) SubmitServiceCheck(
    ctx context.Context,
    body []datadogV1.ServiceCheck,
) (datadogV1.IntakePayloadAccepted, *http.Response, error)

Submit service check statuses.

Key Types

type ServiceCheck struct {
    Check     string
    HostName  string
    Message   *string
    Status    datadogV1.ServiceCheckStatus
    Tags      []string
    Timestamp *int64
}

func NewServiceCheck(check string, hostName string, status datadogV1.ServiceCheckStatus) *ServiceCheck

Example Usage

// Submit a service check
check := datadogV1.NewServiceCheck(
    "app.health_check",
    "web-server-01",
    datadogV1.SERVICECHECKSTATUS_OK,
)
check.SetMessage("Application is healthy")
check.SetTags([]string{"env:production", "service:api"})
check.SetTimestamp(time.Now().Unix())

resp, r, err := serviceChecksApi.SubmitServiceCheck(ctx, []datadogV1.ServiceCheck{*check})
if err != nil {
    fmt.Fprintf(os.Stderr, "Error submitting service check: %v\n", err)
    return
}

fmt.Printf("Service check submitted: %s\n", resp.GetStatus())

Install with Tessl CLI

npx tessl i tessl/golang-github-com-data-dog--datadog-api-client-go-v2

docs

v1

additional-apis.md

dashboards.md

logs-metrics-events.md

monitoring.md

common-package.md

index.md

tile.json