Struct MetricsAPI

pub struct MetricsAPI { /* private fields */ }

The metrics endpoint allows you to:

• Post metrics data so it can be graphed on Datadog’s dashboards
• Query metrics from any time period (timeseries and scalar)
• Modify tag configurations for metrics
• View tags and volumes for metrics

Note: A graph can only contain a set number of points and as the timeframe over which a metric is viewed increases, aggregation between points occurs to stay below that set number.

The Post, Patch, and Delete manage_tags API methods can only be performed by a user who has the Manage Tags for Metrics permission.

See the Metrics page for more information.

Implementations

impl MetricsAPI

pub fn new() -> Self

pub fn with_config(config: Configuration) -> Self

Examples found in repository

examples/v2_metrics_ListMetricAssets.rs (line 8)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.list_metric_assets("system.cpu.user".to_string()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_DeleteTagConfiguration.rs (line 8)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .delete_tag_configuration("ExampleMetric".to_string())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_ListTagConfigurations.rs (line 9)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tag_configurations(ListTagConfigurationsOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_ListVolumesByMetricName.rs (line 8)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_volumes_by_metric_name("static_test_metric_donotdelete".to_string())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_ListTagConfigurations_2739018321.rs (line 9)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tag_configurations(
            ListTagConfigurationsOptionalParams::default().filter_configured(true),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_ListTagConfigurations_265033704.rs (line 9)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tag_configurations(
            ListTagConfigurationsOptionalParams::default().filter_tags("ExampleMetric".to_string()),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Additional examples can be found in:

• examples/v2_metrics_ListActiveMetricConfigurations.rs
• examples/v2_metrics_ListTagConfigurations_3969783727.rs
• examples/v2_metrics_ListTagsByMetricName.rs
• examples/v2_metrics_ListTagConfigurationByName.rs
• examples/v2_metrics_EstimateMetricsOutputSeries.rs
• examples/v2_metrics_SubmitMetrics_1762007427.rs
• examples/v2_metrics_SubmitMetrics.rs
• examples/v2_metrics_DeleteBulkTagsMetricsConfiguration.rs
• examples/v2_metrics_CreateTagConfiguration.rs
• examples/v2_metrics_UpdateTagConfiguration.rs
• examples/v2_metrics_CreateBulkTagsMetricsConfiguration.rs
• examples/v2_metrics_QueryScalarData.rs
• examples/v2_metrics_QueryTimeseriesData.rs
• examples/v2_metrics_QueryScalarData_3112571352.rs
• examples/v2_metrics_QueryTimeseriesData_301142940.rs

pub fn with_client_and_config( config: Configuration, client: ClientWithMiddleware, ) -> Self

pub async fn create_bulk_tags_metrics_configuration( &self, body: MetricBulkTagConfigCreateRequest, ) -> Result<MetricBulkTagConfigResponse, Error<CreateBulkTagsMetricsConfigurationError>>

Create and define a list of queryable tag keys for a set of existing count, gauge, rate, and distribution metrics. Metrics are selected by passing a metric name prefix. Use the Delete method of this API path to remove tag configurations. Results can be sent to a set of account email addresses, just like the same operation in the Datadog web app. If multiple calls include the same metric, the last configuration applied (not by submit order) is used, do not expect deterministic ordering of concurrent calls. The exclude_tags_mode value will set all metrics that match the prefix to the same exclusion state, metric tag configurations do not support mixed inclusion and exclusion for tags on the same metric. Can only be used with application keys of users with the Manage Tags for Metrics permission.

Examples found in repository

examples/v2_metrics_CreateBulkTagsMetricsConfiguration.rs (line 26)

async fn main() {
    // there is a valid "user" in the system
    let user_data_attributes_email = std::env::var("USER_DATA_ATTRIBUTES_EMAIL").unwrap();
    let body = MetricBulkTagConfigCreateRequest::new(
        MetricBulkTagConfigCreate::new(
            "system.load.1".to_string(),
            MetricBulkConfigureTagsType::BULK_MANAGE_TAGS,
        )
        .attributes(
            MetricBulkTagConfigCreateAttributes::new()
                .emails(vec![user_data_attributes_email.clone()])
                .tags(vec!["test".to_string(), "examplemetric".to_string()]),
        ),
    );
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.create_bulk_tags_metrics_configuration(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_bulk_tags_metrics_configuration_with_http_info( &self, body: MetricBulkTagConfigCreateRequest, ) -> Result<ResponseContent<MetricBulkTagConfigResponse>, Error<CreateBulkTagsMetricsConfigurationError>>

Create and define a list of queryable tag keys for a set of existing count, gauge, rate, and distribution metrics. Metrics are selected by passing a metric name prefix. Use the Delete method of this API path to remove tag configurations. Results can be sent to a set of account email addresses, just like the same operation in the Datadog web app. If multiple calls include the same metric, the last configuration applied (not by submit order) is used, do not expect deterministic ordering of concurrent calls. The exclude_tags_mode value will set all metrics that match the prefix to the same exclusion state, metric tag configurations do not support mixed inclusion and exclusion for tags on the same metric. Can only be used with application keys of users with the Manage Tags for Metrics permission.

pub async fn create_tag_configuration( &self, metric_name: String, body: MetricTagConfigurationCreateRequest, ) -> Result<MetricTagConfigurationResponse, Error<CreateTagConfigurationError>>

Create and define a list of queryable tag keys for an existing count/gauge/rate/distribution metric. Optionally, include percentile aggregations on any distribution metric. By setting exclude_tags_mode to true, the behavior is changed from an allow-list to a deny-list, and tags in the defined list are not queryable. Can only be used with application keys of users with the Manage Tags for Metrics permission.

Examples found in repository

examples/v2_metrics_CreateTagConfiguration.rs (line 25)

async fn main() {
    let body = MetricTagConfigurationCreateRequest::new(
        MetricTagConfigurationCreateData::new(
            "ExampleMetric".to_string(),
            MetricTagConfigurationType::MANAGE_TAGS,
        )
        .attributes(MetricTagConfigurationCreateAttributes::new(
            MetricTagConfigurationMetricTypes::GAUGE,
            vec!["app".to_string(), "datacenter".to_string()],
        )),
    );
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .create_tag_configuration("ExampleMetric".to_string(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_tag_configuration_with_http_info( &self, metric_name: String, body: MetricTagConfigurationCreateRequest, ) -> Result<ResponseContent<MetricTagConfigurationResponse>, Error<CreateTagConfigurationError>>

Create and define a list of queryable tag keys for an existing count/gauge/rate/distribution metric. Optionally, include percentile aggregations on any distribution metric. By setting exclude_tags_mode to true, the behavior is changed from an allow-list to a deny-list, and tags in the defined list are not queryable. Can only be used with application keys of users with the Manage Tags for Metrics permission.

pub async fn delete_bulk_tags_metrics_configuration( &self, body: MetricBulkTagConfigDeleteRequest, ) -> Result<MetricBulkTagConfigResponse, Error<DeleteBulkTagsMetricsConfigurationError>>

Delete all custom lists of queryable tag keys for a set of existing count, gauge, rate, and distribution metrics. Metrics are selected by passing a metric name prefix. Results can be sent to a set of account email addresses, just like the same operation in the Datadog web app. Can only be used with application keys of users with the Manage Tags for Metrics permission.

Examples found in repository

examples/v2_metrics_DeleteBulkTagsMetricsConfiguration.rs (line 23)

async fn main() {
    let body = MetricBulkTagConfigDeleteRequest::new(
        MetricBulkTagConfigDelete::new(
            "kafka.lag".to_string(),
            MetricBulkConfigureTagsType::BULK_MANAGE_TAGS,
        )
        .attributes(MetricBulkTagConfigDeleteAttributes::new().emails(vec![
            "sue@example.com".to_string(),
            "bob@example.com".to_string(),
        ])),
    );
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.delete_bulk_tags_metrics_configuration(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn delete_bulk_tags_metrics_configuration_with_http_info( &self, body: MetricBulkTagConfigDeleteRequest, ) -> Result<ResponseContent<MetricBulkTagConfigResponse>, Error<DeleteBulkTagsMetricsConfigurationError>>

Delete all custom lists of queryable tag keys for a set of existing count, gauge, rate, and distribution metrics. Metrics are selected by passing a metric name prefix. Results can be sent to a set of account email addresses, just like the same operation in the Datadog web app. Can only be used with application keys of users with the Manage Tags for Metrics permission.

pub async fn delete_tag_configuration( &self, metric_name: String, ) -> Result<(), Error<DeleteTagConfigurationError>>

Deletes a metric’s tag configuration. Can only be used with application keys from users with the Manage Tags for Metrics permission.

Examples found in repository

examples/v2_metrics_DeleteTagConfiguration.rs (line 10)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .delete_tag_configuration("ExampleMetric".to_string())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn delete_tag_configuration_with_http_info( &self, metric_name: String, ) -> Result<ResponseContent<()>, Error<DeleteTagConfigurationError>>

Deletes a metric’s tag configuration. Can only be used with application keys from users with the Manage Tags for Metrics permission.

pub async fn estimate_metrics_output_series( &self, metric_name: String, params: EstimateMetricsOutputSeriesOptionalParams, ) -> Result<MetricEstimateResponse, Error<EstimateMetricsOutputSeriesError>>

Returns the estimated cardinality for a metric with a given tag, percentile and number of aggregations configuration using Metrics without Limits™.

Examples found in repository

examples/v2_metrics_EstimateMetricsOutputSeries.rs (lines 11-16)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .estimate_metrics_output_series(
            "system.cpu.idle".to_string(),
            EstimateMetricsOutputSeriesOptionalParams::default()
                .filter_groups("app,host".to_string())
                .filter_num_aggregations(4),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn estimate_metrics_output_series_with_http_info( &self, metric_name: String, params: EstimateMetricsOutputSeriesOptionalParams, ) -> Result<ResponseContent<MetricEstimateResponse>, Error<EstimateMetricsOutputSeriesError>>

Returns the estimated cardinality for a metric with a given tag, percentile and number of aggregations configuration using Metrics without Limits™.

pub async fn list_active_metric_configurations( &self, metric_name: String, params: ListActiveMetricConfigurationsOptionalParams, ) -> Result<MetricSuggestedTagsAndAggregationsResponse, Error<ListActiveMetricConfigurationsError>>

List tags and aggregations that are actively queried on dashboards, notebooks, monitors, the Metrics Explorer, and using the API for a given metric name.

Examples found in repository

examples/v2_metrics_ListActiveMetricConfigurations.rs (lines 11-14)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_active_metric_configurations(
            "static_test_metric_donotdelete".to_string(),
            ListActiveMetricConfigurationsOptionalParams::default(),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_active_metric_configurations_with_http_info( &self, metric_name: String, params: ListActiveMetricConfigurationsOptionalParams, ) -> Result<ResponseContent<MetricSuggestedTagsAndAggregationsResponse>, Error<ListActiveMetricConfigurationsError>>

List tags and aggregations that are actively queried on dashboards, notebooks, monitors, the Metrics Explorer, and using the API for a given metric name.

pub async fn list_metric_assets( &self, metric_name: String, ) -> Result<MetricAssetsResponse, Error<ListMetricAssetsError>>

Returns dashboards, monitors, notebooks, and SLOs that a metric is stored in, if any. Updated every 24 hours.

Examples found in repository

examples/v2_metrics_ListMetricAssets.rs (line 9)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.list_metric_assets("system.cpu.user".to_string()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_metric_assets_with_http_info( &self, metric_name: String, ) -> Result<ResponseContent<MetricAssetsResponse>, Error<ListMetricAssetsError>>

Returns dashboards, monitors, notebooks, and SLOs that a metric is stored in, if any. Updated every 24 hours.

pub async fn list_tag_configuration_by_name( &self, metric_name: String, ) -> Result<MetricTagConfigurationResponse, Error<ListTagConfigurationByNameError>>

Returns the tag configuration for the given metric name.

Examples found in repository

examples/v2_metrics_ListTagConfigurationByName.rs (line 13)

async fn main() {
    // there is a valid "metric_tag_configuration" in the system
    let metric_tag_configuration_data_id =
        std::env::var("METRIC_TAG_CONFIGURATION_DATA_ID").unwrap();
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tag_configuration_by_name(metric_tag_configuration_data_id.clone())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_tag_configuration_by_name_with_http_info( &self, metric_name: String, ) -> Result<ResponseContent<MetricTagConfigurationResponse>, Error<ListTagConfigurationByNameError>>

Returns the tag configuration for the given metric name.

pub async fn list_tag_configurations( &self, params: ListTagConfigurationsOptionalParams, ) -> Result<MetricsAndMetricTagConfigurationsResponse, Error<ListTagConfigurationsError>>

Returns all metrics that can be configured in the Metrics Summary page or with Metrics without Limits™ (matching additional filters if specified). Optionally, paginate by using the page[cursor] and/or page[size] query parameters. To fetch the first page, pass in a query parameter with either a valid page[size] or an empty cursor like page[cursor]=. To fetch the next page, pass in the next_cursor value from the response as the new page[cursor] value. Once the meta.pagination.next_cursor value is null, all pages have been retrieved.

Examples found in repository

examples/v2_metrics_ListTagConfigurations.rs (line 11)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tag_configurations(ListTagConfigurationsOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_ListTagConfigurations_2739018321.rs (lines 11-13)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tag_configurations(
            ListTagConfigurationsOptionalParams::default().filter_configured(true),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_ListTagConfigurations_265033704.rs (lines 11-13)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tag_configurations(
            ListTagConfigurationsOptionalParams::default().filter_tags("ExampleMetric".to_string()),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn list_tag_configurations_with_pagination( &self, params: ListTagConfigurationsOptionalParams, ) -> impl Stream<Item = Result<MetricsAndMetricTagConfigurations, Error<ListTagConfigurationsError>>> + '_

Examples found in repository

examples/v2_metrics_ListTagConfigurations_3969783727.rs (lines 12-14)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let response = api.list_tag_configurations_with_pagination(
        ListTagConfigurationsOptionalParams::default().page_size(2),
    );
    pin_mut!(response);
    while let Some(resp) = response.next().await {
        if let Ok(value) = resp {
            println!("{:#?}", value);
        } else {
            println!("{:#?}", resp.unwrap_err());
        }
    }
}

pub async fn list_tag_configurations_with_http_info( &self, params: ListTagConfigurationsOptionalParams, ) -> Result<ResponseContent<MetricsAndMetricTagConfigurationsResponse>, Error<ListTagConfigurationsError>>

Returns all metrics that can be configured in the Metrics Summary page or with Metrics without Limits™ (matching additional filters if specified). Optionally, paginate by using the page[cursor] and/or page[size] query parameters. To fetch the first page, pass in a query parameter with either a valid page[size] or an empty cursor like page[cursor]=. To fetch the next page, pass in the next_cursor value from the response as the new page[cursor] value. Once the meta.pagination.next_cursor value is null, all pages have been retrieved.

pub async fn list_tags_by_metric_name( &self, metric_name: String, ) -> Result<MetricAllTagsResponse, Error<ListTagsByMetricNameError>>

View indexed tag key-value pairs for a given metric name over the previous hour.

Examples found in repository

examples/v2_metrics_ListTagsByMetricName.rs (line 13)

async fn main() {
    // there is a valid "metric_tag_configuration" in the system
    let metric_tag_configuration_data_id =
        std::env::var("METRIC_TAG_CONFIGURATION_DATA_ID").unwrap();
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_tags_by_metric_name(metric_tag_configuration_data_id.clone())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_tags_by_metric_name_with_http_info( &self, metric_name: String, ) -> Result<ResponseContent<MetricAllTagsResponse>, Error<ListTagsByMetricNameError>>

View indexed tag key-value pairs for a given metric name over the previous hour.

pub async fn list_volumes_by_metric_name( &self, metric_name: String, ) -> Result<MetricVolumesResponse, Error<ListVolumesByMetricNameError>>

View distinct metrics volumes for the given metric name.

Custom metrics generated in-app from other products will return null for ingested volumes.

Examples found in repository

examples/v2_metrics_ListVolumesByMetricName.rs (line 10)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .list_volumes_by_metric_name("static_test_metric_donotdelete".to_string())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_volumes_by_metric_name_with_http_info( &self, metric_name: String, ) -> Result<ResponseContent<MetricVolumesResponse>, Error<ListVolumesByMetricNameError>>

View distinct metrics volumes for the given metric name.

Custom metrics generated in-app from other products will return null for ingested volumes.

pub async fn query_scalar_data( &self, body: ScalarFormulaQueryRequest, ) -> Result<ScalarFormulaQueryResponse, Error<QueryScalarDataError>>

Query scalar values (as seen on Query Value, Table, and Toplist widgets). Multiple data sources are supported with the ability to process the data using formulas and functions.

Examples found in repository

examples/v2_metrics_QueryScalarData.rs (line 36)

async fn main() {
    let body = ScalarFormulaQueryRequest::new(ScalarFormulaRequest::new(
        ScalarFormulaRequestAttributes::new(
            1568899800000,
            vec![ScalarQuery::MetricsScalarQuery(Box::new(
                MetricsScalarQuery::new(
                    MetricsAggregator::AVG,
                    MetricsDataSource::METRICS,
                    "avg:system.cpu.user{*} by {env}".to_string(),
                ),
            ))],
            1568923200000,
        )
        .formulas(vec![QueryFormula::new("a+b".to_string())
            .limit(FormulaLimit::new().count(10).order(QuerySortOrder::DESC))]),
        ScalarFormulaRequestType::SCALAR_REQUEST,
    ));
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.query_scalar_data(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_QueryScalarData_3112571352.rs (line 37)

async fn main() {
    let body = ScalarFormulaQueryRequest::new(ScalarFormulaRequest::new(
        ScalarFormulaRequestAttributes::new(
            1636625471000,
            vec![ScalarQuery::MetricsScalarQuery(Box::new(
                MetricsScalarQuery::new(
                    MetricsAggregator::AVG,
                    MetricsDataSource::METRICS,
                    "avg:system.cpu.user{*}".to_string(),
                )
                .name("a".to_string()),
            ))],
            1636629071000,
        )
        .formulas(vec![QueryFormula::new("a".to_string())
            .limit(FormulaLimit::new().count(10).order(QuerySortOrder::DESC))]),
        ScalarFormulaRequestType::SCALAR_REQUEST,
    ));
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.query_scalar_data(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn query_scalar_data_with_http_info( &self, body: ScalarFormulaQueryRequest, ) -> Result<ResponseContent<ScalarFormulaQueryResponse>, Error<QueryScalarDataError>>

Query scalar values (as seen on Query Value, Table, and Toplist widgets). Multiple data sources are supported with the ability to process the data using formulas and functions.

pub async fn query_timeseries_data( &self, body: TimeseriesFormulaQueryRequest, ) -> Result<TimeseriesFormulaQueryResponse, Error<QueryTimeseriesDataError>>

Query timeseries data across various data sources and process the data by applying formulas and functions.

Examples found in repository

examples/v2_metrics_QueryTimeseriesData.rs (line 35)

async fn main() {
    let body = TimeseriesFormulaQueryRequest::new(TimeseriesFormulaRequest::new(
        TimeseriesFormulaRequestAttributes::new(
            1568899800000,
            vec![TimeseriesQuery::MetricsTimeseriesQuery(Box::new(
                MetricsTimeseriesQuery::new(
                    MetricsDataSource::METRICS,
                    "avg:system.cpu.user{*} by {env}".to_string(),
                ),
            ))],
            1568923200000,
        )
        .formulas(vec![QueryFormula::new("a+b".to_string())
            .limit(FormulaLimit::new().count(10).order(QuerySortOrder::DESC))])
        .interval(5000),
        TimeseriesFormulaRequestType::TIMESERIES_REQUEST,
    ));
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.query_timeseries_data(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_QueryTimeseriesData_301142940.rs (line 36)

async fn main() {
    let body = TimeseriesFormulaQueryRequest::new(TimeseriesFormulaRequest::new(
        TimeseriesFormulaRequestAttributes::new(
            1636625471000,
            vec![TimeseriesQuery::MetricsTimeseriesQuery(Box::new(
                MetricsTimeseriesQuery::new(
                    MetricsDataSource::METRICS,
                    "avg:datadog.estimated_usage.metrics.custom{*}".to_string(),
                )
                .name("a".to_string()),
            ))],
            1636629071000,
        )
        .formulas(vec![QueryFormula::new("a".to_string())
            .limit(FormulaLimit::new().count(10).order(QuerySortOrder::DESC))])
        .interval(5000),
        TimeseriesFormulaRequestType::TIMESERIES_REQUEST,
    ));
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api.query_timeseries_data(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn query_timeseries_data_with_http_info( &self, body: TimeseriesFormulaQueryRequest, ) -> Result<ResponseContent<TimeseriesFormulaQueryResponse>, Error<QueryTimeseriesDataError>>

Query timeseries data across various data sources and process the data by applying formulas and functions.

pub async fn submit_metrics( &self, body: MetricPayload, params: SubmitMetricsOptionalParams, ) -> Result<IntakePayloadAccepted, Error<SubmitMetricsError>>

The metrics end-point allows you to post time-series data that can be graphed on Datadog’s dashboards. The maximum payload size is 500 kilobytes (512000 bytes). Compressed payloads must have a decompressed size of less than 5 megabytes (5242880 bytes).

If you’re submitting metrics directly to the Datadog API without using DogStatsD, expect:

• 64 bits for the timestamp
• 64 bits for the value
• 20 bytes for the metric names
• 50 bytes for the timeseries
• The full payload is approximately 100 bytes.

Host name is one of the resources in the Resources field.

Examples found in repository

examples/v2_metrics_SubmitMetrics_1762007427.rs (lines 21-24)

async fn main() {
    let body = MetricPayload::new(vec![MetricSeries::new(
        "system.load.1".to_string(),
        vec![MetricPoint::new().timestamp(1636629071).value(0.7 as f64)],
    )
    .type_(MetricIntakeType::UNSPECIFIED)]);
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .submit_metrics(
            body,
            SubmitMetricsOptionalParams::default().content_encoding(MetricContentEncoding::ZSTD1),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_metrics_SubmitMetrics.rs (line 24)

async fn main() {
    let body = MetricPayload::new(vec![MetricSeries::new(
        "system.load.1".to_string(),
        vec![MetricPoint::new().timestamp(1636629071).value(0.7 as f64)],
    )
    .resources(vec![MetricResource::new()
        .name("dummyhost".to_string())
        .type_("host".to_string())])
    .type_(MetricIntakeType::UNSPECIFIED)]);
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .submit_metrics(body, SubmitMetricsOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn submit_metrics_with_http_info( &self, body: MetricPayload, params: SubmitMetricsOptionalParams, ) -> Result<ResponseContent<IntakePayloadAccepted>, Error<SubmitMetricsError>>

The metrics end-point allows you to post time-series data that can be graphed on Datadog’s dashboards. The maximum payload size is 500 kilobytes (512000 bytes). Compressed payloads must have a decompressed size of less than 5 megabytes (5242880 bytes).

If you’re submitting metrics directly to the Datadog API without using DogStatsD, expect:

• 64 bits for the timestamp
• 64 bits for the value
• 20 bytes for the metric names
• 50 bytes for the timeseries
• The full payload is approximately 100 bytes.

Host name is one of the resources in the Resources field.

pub async fn update_tag_configuration( &self, metric_name: String, body: MetricTagConfigurationUpdateRequest, ) -> Result<MetricTagConfigurationResponse, Error<UpdateTagConfigurationError>>

Update the tag configuration of a metric or percentile aggregations of a distribution metric or custom aggregations of a count, rate, or gauge metric. By setting exclude_tags_mode to true the behavior is changed from an allow-list to a deny-list, and tags in the defined list will not be queryable. Can only be used with application keys from users with the Manage Tags for Metrics permission. This endpoint requires a tag configuration to be created first.

Examples found in repository

examples/v2_metrics_UpdateTagConfiguration.rs (line 24)

async fn main() {
    // there is a valid "metric_tag_configuration" in the system
    let metric_tag_configuration_data_id =
        std::env::var("METRIC_TAG_CONFIGURATION_DATA_ID").unwrap();
    let body = MetricTagConfigurationUpdateRequest::new(
        MetricTagConfigurationUpdateData::new(
            metric_tag_configuration_data_id.clone(),
            MetricTagConfigurationType::MANAGE_TAGS,
        )
        .attributes(MetricTagConfigurationUpdateAttributes::new().tags(vec!["app".to_string()])),
    );
    let configuration = datadog::Configuration::new();
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .update_tag_configuration(metric_tag_configuration_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn update_tag_configuration_with_http_info( &self, metric_name: String, body: MetricTagConfigurationUpdateRequest, ) -> Result<ResponseContent<MetricTagConfigurationResponse>, Error<UpdateTagConfigurationError>>

Update the tag configuration of a metric or percentile aggregations of a distribution metric or custom aggregations of a count, rate, or gauge metric. By setting exclude_tags_mode to true the behavior is changed from an allow-list to a deny-list, and tags in the defined list will not be queryable. Can only be used with application keys from users with the Manage Tags for Metrics permission. This endpoint requires a tag configuration to be created first.

Trait Implementations

impl Clone for MetricsAPI

fn clone(&self) -> MetricsAPI

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MetricsAPI

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MetricsAPI

fn default() -> Self

Returns the “default value” for a type.