# Curl command
curl -X GET "https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com/api/v2/logs/config/metrics" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}"



           

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "os"
    datadog "github.com/DataDog/datadog-api-client-go/api/v2/datadog"
)

func main() {
    ctx := datadog.NewDefaultContext(context.Background())


    configuration := datadog.NewConfiguration()

    apiClient := datadog.NewAPIClient(configuration)
    resp, r, err := apiClient.LogsMetricsApi.ListLogsMetrics(ctx)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `LogsMetricsApi.ListLogsMetrics`: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListLogsMetrics`: LogsMetricsResponse
    responseContent, _ := json.MarshalIndent(resp, "", "  ")
    fmt.Fprintf(os.Stdout, "Response from LogsMetricsApi.ListLogsMetrics:\n%s\n", responseContent)
}

import os
from dateutil.parser import parse as dateutil_parser
from datadog_api_client.v2 import ApiClient, ApiException, Configuration
from datadog_api_client.v2.api import logs_metrics_api
from datadog_api_client.v2.models import *
from pprint import pprint
# See configuration.py for a list of all supported configuration parameters.
configuration = Configuration()

# Enter a context with an instance of the API client
with ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = logs_metrics_api.LogsMetricsApi(api_client)

    # example, this endpoint has no required or optional parameters
    try:
        # Get all log-based metrics
        api_response = api_instance.list_logs_metrics()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling LogsMetricsApi->list_logs_metrics: %s\n" % e)

require 'datadog_api_client'
api_instance = DatadogAPIClient::V2::LogsMetricsAPI.new

begin
  # Get all log-based metrics
  result = api_instance.list_logs_metrics
  p result
rescue DatadogAPIClient::V2::APIError => e
  puts "Error when calling LogsMetricsAPI->list_logs_metrics: #{e}"
end

import { v2 } from '@datadog/datadog-api-client';
import * as fs from 'fs';

const configuration = v2.createConfiguration();
const apiInstance = new v2.LogsMetricsApi(configuration);


apiInstance.listLogsMetrics().then((data:any) => {
  console.log('API called successfully. Returned data: ' + JSON.stringify(data));
}).catch((error:any) => console.error(error));

import java.util.*;
import com.datadog.api.v2.client.ApiClient;
import com.datadog.api.v2.client.ApiException;
import com.datadog.api.v2.client.Configuration;
import com.datadog.api.v2.client.model.*;
import com.datadog.api.v2.client.api.LogsMetricsApi;

public class Example {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        LogsMetricsApi apiInstance = new LogsMetricsApi(defaultClient);
        try {
            LogsMetricsResponse result = apiInstance.listLogsMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogsMetricsApi#listLogsMetrics");
            System.err.println("Status code: " + e.getCode());
            System.err.println("Reason: " + e.getResponseBody());
            System.err.println("Response headers: " + e.getResponseHeaders());
            e.printStackTrace();
        }
    }
}

# Curl command
curl -X POST "https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com/api/v2/logs/config/metrics" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "compute": {
        "aggregation_type": "distribution"
      },
      "group_by": [
        {
          "path": "@http.status_code"
        }
      ]
    },
    "id": "logs.page.load.count",
    "type": "logs_metrics"
  }
}
EOF



           

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "os"
    datadog "github.com/DataDog/datadog-api-client-go/api/v2/datadog"
)

func main() {
    ctx := datadog.NewDefaultContext(context.Background())

    body := *datadog.NewLogsMetricCreateRequest(*datadog.NewLogsMetricCreateData(*datadog.NewLogsMetricCreateAttributes(*datadog.NewLogsMetricCompute(datadog.LogsMetricComputeAggregationType("count"))), "logs.page.load.count", datadog.LogsMetricType("logs_metrics"))) // LogsMetricCreateRequest | The definition of the new log-based metric.

    configuration := datadog.NewConfiguration()

    apiClient := datadog.NewAPIClient(configuration)
    resp, r, err := apiClient.LogsMetricsApi.CreateLogsMetric(ctx, body)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `LogsMetricsApi.CreateLogsMetric`: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateLogsMetric`: LogsMetricResponse
    responseContent, _ := json.MarshalIndent(resp, "", "  ")
    fmt.Fprintf(os.Stdout, "Response from LogsMetricsApi.CreateLogsMetric:\n%s\n", responseContent)
}

import os
from dateutil.parser import parse as dateutil_parser
from datadog_api_client.v2 import ApiClient, ApiException, Configuration
from datadog_api_client.v2.api import logs_metrics_api
from datadog_api_client.v2.models import *
from pprint import pprint
# See configuration.py for a list of all supported configuration parameters.
configuration = Configuration()

# Enter a context with an instance of the API client
with ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = logs_metrics_api.LogsMetricsApi(api_client)
    body = LogsMetricCreateRequest(
        data=LogsMetricCreateData(
            attributes=LogsMetricCreateAttributes(
                compute=LogsMetricCompute(
                    aggregation_type=LogsMetricComputeAggregationType("distribution"),
                    path="@duration",
                ),
                filter=LogsMetricFilter(
                    query="service:web* AND @http.status_code:[200 TO 299]",
                ),
                group_by=[
                    LogsMetricGroupBy(
                        path="@http.status_code",
                        tag_name="status_code",
                    ),
                ],
            ),
            id="logs.page.load.count",
            type=LogsMetricType("logs_metrics"),
        ),
    )  # LogsMetricCreateRequest | The definition of the new log-based metric.

    # example passing only required values which don't have defaults set
    try:
        # Create a log-based metric
        api_response = api_instance.create_logs_metric(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling LogsMetricsApi->create_logs_metric: %s\n" % e)

require 'datadog_api_client'
api_instance = DatadogAPIClient::V2::LogsMetricsAPI.new
body = DatadogAPIClient::V2::LogsMetricCreateRequest.new({data: DatadogAPIClient::V2::LogsMetricCreateData.new({attributes: DatadogAPIClient::V2::LogsMetricCreateAttributes.new({compute: DatadogAPIClient::V2::LogsMetricCompute.new({aggregation_type: DatadogAPIClient::V2::LogsMetricComputeAggregationType::COUNT})}), id: 'logs.page.load.count', type: DatadogAPIClient::V2::LogsMetricType::LOGS_METRICS})}) # LogsMetricCreateRequest | The definition of the new log-based metric.

begin
  # Create a log-based metric
  result = api_instance.create_logs_metric(body)
  p result
rescue DatadogAPIClient::V2::APIError => e
  puts "Error when calling LogsMetricsAPI->create_logs_metric: #{e}"
end

import { v2 } from '@datadog/datadog-api-client';
import * as fs from 'fs';

const configuration = v2.createConfiguration();
const apiInstance = new v2.LogsMetricsApi(configuration);

let params:v2.LogsMetricsApiCreateLogsMetricRequest = {
  // LogsMetricCreateRequest | The definition of the new log-based metric.
  body: {
    data: {
      attributes: {
        compute: {
          aggregationType: "distribution",
          path: "@duration",
        },
        filter: {
          query: "service:web* AND @http.status_code:[200 TO 299]",
        },
        groupBy: [
          {
            path: "@http.status_code",
            tagName: "status_code",
          },
        ],
      },
      id: "logs.page.load.count",
      type: "logs_metrics",
    },
  },
};

apiInstance.createLogsMetric(params).then((data:any) => {
  console.log('API called successfully. Returned data: ' + JSON.stringify(data));
}).catch((error:any) => console.error(error));

import java.util.*;
import com.datadog.api.v2.client.ApiClient;
import com.datadog.api.v2.client.ApiException;
import com.datadog.api.v2.client.Configuration;
import com.datadog.api.v2.client.model.*;
import com.datadog.api.v2.client.api.LogsMetricsApi;

public class Example {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        LogsMetricsApi apiInstance = new LogsMetricsApi(defaultClient);
        LogsMetricCreateRequest body = new LogsMetricCreateRequest(); // LogsMetricCreateRequest | The definition of the new log-based metric.
        try {
            LogsMetricResponse result = apiInstance.createLogsMetric(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogsMetricsApi#createLogsMetric");
            System.err.println("Status code: " + e.getCode());
            System.err.println("Reason: " + e.getResponseBody());
            System.err.println("Response headers: " + e.getResponseHeaders());
            e.printStackTrace();
        }
    }
}

# Path parameters
export metric_id="CHANGE_ME"
# Curl command
curl -X GET "https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com/api/v2/logs/config/metrics/${metric_id}" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}"



           

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "os"
    datadog "github.com/DataDog/datadog-api-client-go/api/v2/datadog"
)

func main() {
    ctx := datadog.NewDefaultContext(context.Background())

    metricId := "metricId_example" // string | The name of the log-based metric.

    configuration := datadog.NewConfiguration()

    apiClient := datadog.NewAPIClient(configuration)
    resp, r, err := apiClient.LogsMetricsApi.GetLogsMetric(ctx, metricId)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `LogsMetricsApi.GetLogsMetric`: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetLogsMetric`: LogsMetricResponse
    responseContent, _ := json.MarshalIndent(resp, "", "  ")
    fmt.Fprintf(os.Stdout, "Response from LogsMetricsApi.GetLogsMetric:\n%s\n", responseContent)
}

import os
from dateutil.parser import parse as dateutil_parser
from datadog_api_client.v2 import ApiClient, ApiException, Configuration
from datadog_api_client.v2.api import logs_metrics_api
from datadog_api_client.v2.models import *
from pprint import pprint
# See configuration.py for a list of all supported configuration parameters.
configuration = Configuration()

# Enter a context with an instance of the API client
with ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = logs_metrics_api.LogsMetricsApi(api_client)
    metric_id = "metric_id_example"  # str | The name of the log-based metric.

    # example passing only required values which don't have defaults set
    try:
        # Get a log-based metric
        api_response = api_instance.get_logs_metric(metric_id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling LogsMetricsApi->get_logs_metric: %s\n" % e)

require 'datadog_api_client'
api_instance = DatadogAPIClient::V2::LogsMetricsAPI.new
metric_id = 'metric_id_example' # String | The name of the log-based metric.

begin
  # Get a log-based metric
  result = api_instance.get_logs_metric(metric_id)
  p result
rescue DatadogAPIClient::V2::APIError => e
  puts "Error when calling LogsMetricsAPI->get_logs_metric: #{e}"
end

import { v2 } from '@datadog/datadog-api-client';
import * as fs from 'fs';

const configuration = v2.createConfiguration();
const apiInstance = new v2.LogsMetricsApi(configuration);

let params:v2.LogsMetricsApiGetLogsMetricRequest = {
  // string | The name of the log-based metric.
  metricId: "metric_id_example",
};

apiInstance.getLogsMetric(params).then((data:any) => {
  console.log('API called successfully. Returned data: ' + JSON.stringify(data));
}).catch((error:any) => console.error(error));

import java.util.*;
import com.datadog.api.v2.client.ApiClient;
import com.datadog.api.v2.client.ApiException;
import com.datadog.api.v2.client.Configuration;
import com.datadog.api.v2.client.model.*;
import com.datadog.api.v2.client.api.LogsMetricsApi;

public class Example {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        LogsMetricsApi apiInstance = new LogsMetricsApi(defaultClient);
        String metricId = "metricId_example"; // String | The name of the log-based metric.
        try {
            LogsMetricResponse result = apiInstance.getLogsMetric(metricId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogsMetricsApi#getLogsMetric");
            System.err.println("Status code: " + e.getCode());
            System.err.println("Reason: " + e.getResponseBody());
            System.err.println("Response headers: " + e.getResponseHeaders());
            e.printStackTrace();
        }
    }
}

# Path parameters
export metric_id="CHANGE_ME"
# Curl command
curl -X PATCH "https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com/api/v2/logs/config/metrics/${metric_id}" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "group_by": [
        {
          "path": "@http.status_code"
        }
      ]
    },
    "type": "logs_metrics"
  }
}
EOF



           

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "os"
    datadog "github.com/DataDog/datadog-api-client-go/api/v2/datadog"
)

func main() {
    ctx := datadog.NewDefaultContext(context.Background())

    metricId := "metricId_example" // string | The name of the log-based metric.
    body := *datadog.NewLogsMetricUpdateRequest(*datadog.NewLogsMetricUpdateData(*datadog.NewLogsMetricUpdateAttributes(), datadog.LogsMetricType("logs_metrics"))) // LogsMetricUpdateRequest | New definition of the log-based metric.

    configuration := datadog.NewConfiguration()

    apiClient := datadog.NewAPIClient(configuration)
    resp, r, err := apiClient.LogsMetricsApi.UpdateLogsMetric(ctx, metricId, body)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `LogsMetricsApi.UpdateLogsMetric`: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateLogsMetric`: LogsMetricResponse
    responseContent, _ := json.MarshalIndent(resp, "", "  ")
    fmt.Fprintf(os.Stdout, "Response from LogsMetricsApi.UpdateLogsMetric:\n%s\n", responseContent)
}

import os
from dateutil.parser import parse as dateutil_parser
from datadog_api_client.v2 import ApiClient, ApiException, Configuration
from datadog_api_client.v2.api import logs_metrics_api
from datadog_api_client.v2.models import *
from pprint import pprint
# See configuration.py for a list of all supported configuration parameters.
configuration = Configuration()

# Enter a context with an instance of the API client
with ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = logs_metrics_api.LogsMetricsApi(api_client)
    metric_id = "metric_id_example"  # str | The name of the log-based metric.
    body = LogsMetricUpdateRequest(
        data=LogsMetricUpdateData(
            attributes=LogsMetricUpdateAttributes(
                filter=LogsMetricFilter(
                    query="service:web* AND @http.status_code:[200 TO 299]",
                ),
                group_by=[
                    LogsMetricGroupBy(
                        path="@http.status_code",
                        tag_name="status_code",
                    ),
                ],
            ),
            type=LogsMetricType("logs_metrics"),
        ),
    )  # LogsMetricUpdateRequest | New definition of the log-based metric.

    # example passing only required values which don't have defaults set
    try:
        # Update a log-based metric
        api_response = api_instance.update_logs_metric(metric_id, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling LogsMetricsApi->update_logs_metric: %s\n" % e)

require 'datadog_api_client'
api_instance = DatadogAPIClient::V2::LogsMetricsAPI.new
metric_id = 'metric_id_example' # String | The name of the log-based metric.
body = DatadogAPIClient::V2::LogsMetricUpdateRequest.new({data: DatadogAPIClient::V2::LogsMetricUpdateData.new({attributes: DatadogAPIClient::V2::LogsMetricUpdateAttributes.new, type: DatadogAPIClient::V2::LogsMetricType::LOGS_METRICS})}) # LogsMetricUpdateRequest | New definition of the log-based metric.

begin
  # Update a log-based metric
  result = api_instance.update_logs_metric(metric_id, body)
  p result
rescue DatadogAPIClient::V2::APIError => e
  puts "Error when calling LogsMetricsAPI->update_logs_metric: #{e}"
end

import { v2 } from '@datadog/datadog-api-client';
import * as fs from 'fs';

const configuration = v2.createConfiguration();
const apiInstance = new v2.LogsMetricsApi(configuration);

let params:v2.LogsMetricsApiUpdateLogsMetricRequest = {
  // string | The name of the log-based metric.
  metricId: "metric_id_example",
  // LogsMetricUpdateRequest | New definition of the log-based metric.
  body: {
    data: {
      attributes: {
        filter: {
          query: "service:web* AND @http.status_code:[200 TO 299]",
        },
        groupBy: [
          {
            path: "@http.status_code",
            tagName: "status_code",
          },
        ],
      },
      type: "logs_metrics",
    },
  },
};

apiInstance.updateLogsMetric(params).then((data:any) => {
  console.log('API called successfully. Returned data: ' + JSON.stringify(data));
}).catch((error:any) => console.error(error));

import java.util.*;
import com.datadog.api.v2.client.ApiClient;
import com.datadog.api.v2.client.ApiException;
import com.datadog.api.v2.client.Configuration;
import com.datadog.api.v2.client.model.*;
import com.datadog.api.v2.client.api.LogsMetricsApi;

public class Example {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        LogsMetricsApi apiInstance = new LogsMetricsApi(defaultClient);
        String metricId = "metricId_example"; // String | The name of the log-based metric.
        LogsMetricUpdateRequest body = new LogsMetricUpdateRequest(); // LogsMetricUpdateRequest | New definition of the log-based metric.
        try {
            LogsMetricResponse result = apiInstance.updateLogsMetric(metricId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogsMetricsApi#updateLogsMetric");
            System.err.println("Status code: " + e.getCode());
            System.err.println("Reason: " + e.getResponseBody());
            System.err.println("Response headers: " + e.getResponseHeaders());
            e.printStackTrace();
        }
    }
}

# Path parameters
export metric_id="CHANGE_ME"
# Curl command
curl -X DELETE "https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com/api/v2/logs/config/metrics/${metric_id}" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}"



           

package main

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

func main() {
    ctx := datadog.NewDefaultContext(context.Background())

    metricId := "metricId_example" // string | The name of the log-based metric.

    configuration := datadog.NewConfiguration()

    apiClient := datadog.NewAPIClient(configuration)
    r, err := apiClient.LogsMetricsApi.DeleteLogsMetric(ctx, metricId)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `LogsMetricsApi.DeleteLogsMetric`: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
}

import os
from dateutil.parser import parse as dateutil_parser
from datadog_api_client.v2 import ApiClient, ApiException, Configuration
from datadog_api_client.v2.api import logs_metrics_api
from datadog_api_client.v2.models import *
from pprint import pprint
# See configuration.py for a list of all supported configuration parameters.
configuration = Configuration()

# Enter a context with an instance of the API client
with ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = logs_metrics_api.LogsMetricsApi(api_client)
    metric_id = "metric_id_example"  # str | The name of the log-based metric.

    # example passing only required values which don't have defaults set
    try:
        # Delete a log-based metric
        api_instance.delete_logs_metric(metric_id)
    except ApiException as e:
        print("Exception when calling LogsMetricsApi->delete_logs_metric: %s\n" % e)

require 'datadog_api_client'
api_instance = DatadogAPIClient::V2::LogsMetricsAPI.new
metric_id = 'metric_id_example' # String | The name of the log-based metric.

begin
  # Delete a log-based metric
  api_instance.delete_logs_metric(metric_id)
rescue DatadogAPIClient::V2::APIError => e
  puts "Error when calling LogsMetricsAPI->delete_logs_metric: #{e}"
end

import { v2 } from '@datadog/datadog-api-client';
import * as fs from 'fs';

const configuration = v2.createConfiguration();
const apiInstance = new v2.LogsMetricsApi(configuration);

let params:v2.LogsMetricsApiDeleteLogsMetricRequest = {
  // string | The name of the log-based metric.
  metricId: "metric_id_example",
};

apiInstance.deleteLogsMetric(params).then((data:any) => {
  console.log('API called successfully. Returned data: ' + JSON.stringify(data));
}).catch((error:any) => console.error(error));

import java.util.*;
import com.datadog.api.v2.client.ApiClient;
import com.datadog.api.v2.client.ApiException;
import com.datadog.api.v2.client.Configuration;
import com.datadog.api.v2.client.model.*;
import com.datadog.api.v2.client.api.LogsMetricsApi;

public class Example {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        LogsMetricsApi apiInstance = new LogsMetricsApi(defaultClient);
        String metricId = "metricId_example"; // String | The name of the log-based metric.
        try {
            apiInstance.deleteLogsMetric(metricId);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogsMetricsApi#deleteLogsMetric");
            System.err.println("Status code: " + e.getCode());
            System.err.println("Reason: " + e.getResponseBody());
            System.err.println("Response headers: " + e.getResponseHeaders());
            e.printStackTrace();
        }
    }
}