@datadog/datadog-api-client

import { BaseAPIRequestFactory } from "../../datadog-api-client-common/baseapi"; import { Configuration } from "../../datadog-api-client-common/configuration"; import { RequestContext, ResponseContext } from "../../datadog-api-client-common/http/http"; import { IntakePayloadAccepted } from "../models/IntakePayloadAccepted"; import { MetricAllTagsResponse } from "../models/MetricAllTagsResponse"; import { MetricAssetsResponse } from "../models/MetricAssetsResponse"; import { MetricBulkTagConfigCreateRequest } from "../models/MetricBulkTagConfigCreateRequest"; import { MetricBulkTagConfigDeleteRequest } from "../models/MetricBulkTagConfigDeleteRequest"; import { MetricBulkTagConfigResponse } from "../models/MetricBulkTagConfigResponse"; import { MetricContentEncoding } from "../models/MetricContentEncoding"; import { MetricEstimateResponse } from "../models/MetricEstimateResponse"; import { MetricPayload } from "../models/MetricPayload"; import { MetricsAndMetricTagConfigurations } from "../models/MetricsAndMetricTagConfigurations"; import { MetricsAndMetricTagConfigurationsResponse } from "../models/MetricsAndMetricTagConfigurationsResponse"; import { MetricSuggestedTagsAndAggregationsResponse } from "../models/MetricSuggestedTagsAndAggregationsResponse"; import { MetricTagCardinalitiesResponse } from "../models/MetricTagCardinalitiesResponse"; import { MetricTagConfigurationCreateRequest } from "../models/MetricTagConfigurationCreateRequest"; import { MetricTagConfigurationMetricTypeCategory } from "../models/MetricTagConfigurationMetricTypeCategory"; import { MetricTagConfigurationResponse } from "../models/MetricTagConfigurationResponse"; import { MetricTagConfigurationUpdateRequest } from "../models/MetricTagConfigurationUpdateRequest"; import { MetricVolumesResponse } from "../models/MetricVolumesResponse"; import { ScalarFormulaQueryRequest } from "../models/ScalarFormulaQueryRequest"; import { ScalarFormulaQueryResponse } from "../models/ScalarFormulaQueryResponse"; import { TagIndexingRuleCreateRequest } from "../models/TagIndexingRuleCreateRequest"; import { TagIndexingRuleExemptionCreateRequest } from "../models/TagIndexingRuleExemptionCreateRequest"; import { TagIndexingRuleExemptionResponse } from "../models/TagIndexingRuleExemptionResponse"; import { TagIndexingRuleOrderRequest } from "../models/TagIndexingRuleOrderRequest"; import { TagIndexingRuleResponse } from "../models/TagIndexingRuleResponse"; import { TagIndexingRulesResponse } from "../models/TagIndexingRulesResponse"; import { TagIndexingRuleUpdateRequest } from "../models/TagIndexingRuleUpdateRequest"; import { TimeseriesFormulaQueryRequest } from "../models/TimeseriesFormulaQueryRequest"; import { TimeseriesFormulaQueryResponse } from "../models/TimeseriesFormulaQueryResponse"; export declare class MetricsApiRequestFactory extends BaseAPIRequestFactory { createBulkTagsMetricsConfiguration(body: MetricBulkTagConfigCreateRequest, _options?: Configuration): Promise<RequestContext>; createTagConfiguration(metricName: string, body: MetricTagConfigurationCreateRequest, _options?: Configuration): Promise<RequestContext>; createTagIndexingRule(body: TagIndexingRuleCreateRequest, _options?: Configuration): Promise<RequestContext>; createTagIndexingRuleExemption(metricName: string, body: TagIndexingRuleExemptionCreateRequest, _options?: Configuration): Promise<RequestContext>; deleteBulkTagsMetricsConfiguration(body: MetricBulkTagConfigDeleteRequest, _options?: Configuration): Promise<RequestContext>; deleteTagConfiguration(metricName: string, _options?: Configuration): Promise<RequestContext>; deleteTagIndexingRule(id: string, _options?: Configuration): Promise<RequestContext>; deleteTagIndexingRuleExemption(metricName: string, _options?: Configuration): Promise<RequestContext>; estimateMetricsOutputSeries(metricName: string, filterGroups?: string, filterHoursAgo?: number, filterNumAggregations?: number, filterPct?: boolean, filterTimespanH?: number, _options?: Configuration): Promise<RequestContext>; getMetricTagCardinalityDetails(metricName: string, _options?: Configuration): Promise<RequestContext>; getTagIndexingRule(id: string, _options?: Configuration): Promise<RequestContext>; getTagIndexingRuleExemption(metricName: string, _options?: Configuration): Promise<RequestContext>; listActiveMetricConfigurations(metricName: string, windowSeconds?: number, _options?: Configuration): Promise<RequestContext>; listMetricAssets(metricName: string, _options?: Configuration): Promise<RequestContext>; listTagConfigurationByName(metricName: string, _options?: Configuration): Promise<RequestContext>; listTagConfigurations(filterConfigured?: boolean, filterIsConfigurable?: boolean, filterTagsConfigured?: string, filterMetricType?: MetricTagConfigurationMetricTypeCategory, filterIncludePercentiles?: boolean, filterQueried?: boolean, filterQueriedWindowSeconds?: number, filterTags?: string, filterRelatedAssets?: boolean, include?: string, sort?: string, windowSeconds?: number, pageSize?: number, pageCursor?: string, _options?: Configuration): Promise<RequestContext>; listTagIndexingRules(pageLimit?: number, pageOffset?: number, search?: string, _options?: Configuration): Promise<RequestContext>; listTagIndexingRulesForMetric(metricName: string, _options?: Configuration): Promise<RequestContext>; listTagsByMetricName(metricName: string, windowSeconds?: number, filterTags?: string, filterMatch?: string, filterIncludeTagValues?: boolean, filterAllowPartial?: boolean, pageLimit?: number, _options?: Configuration): Promise<RequestContext>; listVolumesByMetricName(metricName: string, windowSeconds?: number, _options?: Configuration): Promise<RequestContext>; queryScalarData(body: ScalarFormulaQueryRequest, _options?: Configuration): Promise<RequestContext>; queryTimeseriesData(body: TimeseriesFormulaQueryRequest, _options?: Configuration): Promise<RequestContext>; reorderTagIndexingRules(body: TagIndexingRuleOrderRequest, _options?: Configuration): Promise<RequestContext>; submitMetrics(body: MetricPayload, contentEncoding?: MetricContentEncoding, _options?: Configuration): Promise<RequestContext>; updateTagConfiguration(metricName: string, body: MetricTagConfigurationUpdateRequest, _options?: Configuration): Promise<RequestContext>; updateTagIndexingRule(id: string, body: TagIndexingRuleUpdateRequest, _options?: Configuration): Promise<RequestContext>; } export declare class MetricsApiResponseProcessor { /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to createBulkTagsMetricsConfiguration * @throws ApiException if the response code was not in [200, 299] */ createBulkTagsMetricsConfiguration(response: ResponseContext): Promise<MetricBulkTagConfigResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to createTagConfiguration * @throws ApiException if the response code was not in [200, 299] */ createTagConfiguration(response: ResponseContext): Promise<MetricTagConfigurationResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to createTagIndexingRule * @throws ApiException if the response code was not in [200, 299] */ createTagIndexingRule(response: ResponseContext): Promise<TagIndexingRuleResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to createTagIndexingRuleExemption * @throws ApiException if the response code was not in [200, 299] */ createTagIndexingRuleExemption(response: ResponseContext): Promise<TagIndexingRuleExemptionResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to deleteBulkTagsMetricsConfiguration * @throws ApiException if the response code was not in [200, 299] */ deleteBulkTagsMetricsConfiguration(response: ResponseContext): Promise<MetricBulkTagConfigResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to deleteTagConfiguration * @throws ApiException if the response code was not in [200, 299] */ deleteTagConfiguration(response: ResponseContext): Promise<void>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to deleteTagIndexingRule * @throws ApiException if the response code was not in [200, 299] */ deleteTagIndexingRule(response: ResponseContext): Promise<void>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to deleteTagIndexingRuleExemption * @throws ApiException if the response code was not in [200, 299] */ deleteTagIndexingRuleExemption(response: ResponseContext): Promise<void>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to estimateMetricsOutputSeries * @throws ApiException if the response code was not in [200, 299] */ estimateMetricsOutputSeries(response: ResponseContext): Promise<MetricEstimateResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to getMetricTagCardinalityDetails * @throws ApiException if the response code was not in [200, 299] */ getMetricTagCardinalityDetails(response: ResponseContext): Promise<MetricTagCardinalitiesResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to getTagIndexingRule * @throws ApiException if the response code was not in [200, 299] */ getTagIndexingRule(response: ResponseContext): Promise<TagIndexingRuleResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to getTagIndexingRuleExemption * @throws ApiException if the response code was not in [200, 299] */ getTagIndexingRuleExemption(response: ResponseContext): Promise<TagIndexingRuleExemptionResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listActiveMetricConfigurations * @throws ApiException if the response code was not in [200, 299] */ listActiveMetricConfigurations(response: ResponseContext): Promise<MetricSuggestedTagsAndAggregationsResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listMetricAssets * @throws ApiException if the response code was not in [200, 299] */ listMetricAssets(response: ResponseContext): Promise<MetricAssetsResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listTagConfigurationByName * @throws ApiException if the response code was not in [200, 299] */ listTagConfigurationByName(response: ResponseContext): Promise<MetricTagConfigurationResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listTagConfigurations * @throws ApiException if the response code was not in [200, 299] */ listTagConfigurations(response: ResponseContext): Promise<MetricsAndMetricTagConfigurationsResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listTagIndexingRules * @throws ApiException if the response code was not in [200, 299] */ listTagIndexingRules(response: ResponseContext): Promise<TagIndexingRulesResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listTagIndexingRulesForMetric * @throws ApiException if the response code was not in [200, 299] */ listTagIndexingRulesForMetric(response: ResponseContext): Promise<TagIndexingRulesResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listTagsByMetricName * @throws ApiException if the response code was not in [200, 299] */ listTagsByMetricName(response: ResponseContext): Promise<MetricAllTagsResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to listVolumesByMetricName * @throws ApiException if the response code was not in [200, 299] */ listVolumesByMetricName(response: ResponseContext): Promise<MetricVolumesResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to queryScalarData * @throws ApiException if the response code was not in [200, 299] */ queryScalarData(response: ResponseContext): Promise<ScalarFormulaQueryResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to queryTimeseriesData * @throws ApiException if the response code was not in [200, 299] */ queryTimeseriesData(response: ResponseContext): Promise<TimeseriesFormulaQueryResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to reorderTagIndexingRules * @throws ApiException if the response code was not in [200, 299] */ reorderTagIndexingRules(response: ResponseContext): Promise<void>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to submitMetrics * @throws ApiException if the response code was not in [200, 299] */ submitMetrics(response: ResponseContext): Promise<IntakePayloadAccepted>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to updateTagConfiguration * @throws ApiException if the response code was not in [200, 299] */ updateTagConfiguration(response: ResponseContext): Promise<MetricTagConfigurationResponse>; /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects * * @params response Response returned by the server for a request to updateTagIndexingRule * @throws ApiException if the response code was not in [200, 299] */ updateTagIndexingRule(response: ResponseContext): Promise<TagIndexingRuleResponse>; } export interface MetricsApiCreateBulkTagsMetricsConfigurationRequest { /** * @type MetricBulkTagConfigCreateRequest */ body: MetricBulkTagConfigCreateRequest; } export interface MetricsApiCreateTagConfigurationRequest { /** * The name of the metric. * @type string */ metricName: string; /** * @type MetricTagConfigurationCreateRequest */ body: MetricTagConfigurationCreateRequest; } export interface MetricsApiCreateTagIndexingRuleRequest { /** * @type TagIndexingRuleCreateRequest */ body: TagIndexingRuleCreateRequest; } export interface MetricsApiCreateTagIndexingRuleExemptionRequest { /** * The name of the metric. * @type string */ metricName: string; /** * @type TagIndexingRuleExemptionCreateRequest */ body: TagIndexingRuleExemptionCreateRequest; } export interface MetricsApiDeleteBulkTagsMetricsConfigurationRequest { /** * @type MetricBulkTagConfigDeleteRequest */ body: MetricBulkTagConfigDeleteRequest; } export interface MetricsApiDeleteTagConfigurationRequest { /** * The name of the metric. * @type string */ metricName: string; } export interface MetricsApiDeleteTagIndexingRuleRequest { /** * ID of the tag indexing rule. * @type string */ id: string; } export interface MetricsApiDeleteTagIndexingRuleExemptionRequest { /** * The name of the metric. * @type string */ metricName: string; } export interface MetricsApiEstimateMetricsOutputSeriesRequest { /** * The name of the metric. * @type string */ metricName: string; /** * Comma-separated list of tag keys that the metric is configured to query with. For example: `filter[groups]=app,host`. * @type string */ filterGroups?: string; /** * The number of hours of look back (from now) to estimate cardinality with. If unspecified, it defaults to 0 hours. * @type number */ filterHoursAgo?: number; /** * Deprecated. Number of aggregations has no impact on volume. * @type number */ filterNumAggregations?: number; /** * A boolean, for distribution metrics only, to estimate cardinality if the metric includes additional percentile aggregators. * @type boolean */ filterPct?: boolean; /** * A window, in hours, from the look back to estimate cardinality with. The minimum and default is 1 hour. * @type number */ filterTimespanH?: number; } export interface MetricsApiGetMetricTagCardinalityDetailsRequest { /** * The name of the metric. * @type string */ metricName: string; } export interface MetricsApiGetTagIndexingRuleRequest { /** * ID of the tag indexing rule. * @type string */ id: string; } export interface MetricsApiGetTagIndexingRuleExemptionRequest { /** * The name of the metric. * @type string */ metricName: string; } export interface MetricsApiListActiveMetricConfigurationsRequest { /** * The name of the metric. * @type string */ metricName: string; /** * The number of seconds of look back (from now). * Default value is 604,800 (1 week), minimum value is 7200 (2 hours), maximum value is 2,630,000 (1 month). * @type number */ windowSeconds?: number; } export interface MetricsApiListMetricAssetsRequest { /** * The name of the metric. * @type string */ metricName: string; } export interface MetricsApiListTagConfigurationByNameRequest { /** * The name of the metric. * @type string */ metricName: string; } export interface MetricsApiListTagConfigurationsRequest { /** * Only return custom metrics that have been configured (`true`) or not configured (`false`) with Metrics Without Limits. * @type boolean */ filterConfigured?: boolean; /** * Only return metrics that are eligible (`true`) or ineligible (`false`) for configuration with Metrics Without Limits. * @type boolean */ filterIsConfigurable?: boolean; /** * Only return metrics that have the given tag key(s) in their Metrics Without Limits configuration (included or excluded). * @type string */ filterTagsConfigured?: string; /** * Only return metrics of the given metric type. * @type MetricTagConfigurationMetricTypeCategory */ filterMetricType?: MetricTagConfigurationMetricTypeCategory; /** * Only return distribution metrics that have percentile aggregations enabled (true) or disabled (false). * @type boolean */ filterIncludePercentiles?: boolean; /** * Only return metrics that have been queried (true) or not queried (false) in the look back window. Set the window with `filter[queried][window][seconds]`; if omitted, a default window is used. * @type boolean */ filterQueried?: boolean; /** * This parameter has no effect unless `filter[queried]` is also set. Only return metrics that have been queried or not queried in the specified window. The default value is 2,592,000 seconds (30 days), the maximum value is 15,552,000 seconds (180 days), and the minimum value is 1 second. For example: `filter[queried]=true&filter[queried][window][seconds]=604800`. * @type number */ filterQueriedWindowSeconds?: number; /** * Only return metrics that were submitted with tags matching this expression. You can use AND, OR, IN, and wildcards. For example: `filter[tags]=env IN (staging,test) AND service:web*`. * @type string */ filterTags?: string; /** * Only return metrics that are used in at least one dashboard, monitor, notebook, or SLO. * @type boolean */ filterRelatedAssets?: boolean; /** * Include related resources in the response. Set to `metric_volumes` to include indexed and ingested volume counts for each metric. * @type string */ include?: string; /** * Sort results by metric volume. Prefix a key with `-` for descending order. Supported keys: `metric_volumes.indexed_volume`, `metric_volumes.ingested_volume`, `metric_volumes.indexed_volume_delta`, `metric_volumes.ingested_volume_delta`. Requires a paginated request (`page[size]` or `page[cursor]`). * @type string */ sort?: string; /** * Only return metrics that have been actively reporting in the specified window. The default value is 3600 seconds (1 hour), the maximum value is 2,592,000 seconds (30 days), and the minimum value is 1 second. * @type number */ windowSeconds?: number; /** * Maximum number of results per page. Send `page[size]` on the first request to opt in to pagination. On each subsequent request, send `page[cursor]` set to the value of `meta.pagination.next_cursor` from the previous response. The default value is 10000, the maximum value is 10000, and the minimum value is 1. * @type number */ pageSize?: number; /** * Cursor for pagination. Use `page[size]` to opt-in to pagination and get the first page; for subsequent pages, use the value from `meta.pagination.next_cursor` in the response. Pagination is complete when `next_cursor` is null. * @type string */ pageCursor?: string; } export interface MetricsApiListTagIndexingRulesRequest { /** * Page size (1–1000, default 100). * @type number */ pageLimit?: number; /** * Page offset from the start of the list (default 0). * @type number */ pageOffset?: number; /** * Substring filter on rule name. * @type string */ search?: string; } export interface MetricsApiListTagIndexingRulesForMetricRequest { /** * The name of the metric. * @type string */ metricName: string; } export interface MetricsApiListTagsByMetricNameRequest { /** * The name of the metric. * @type string */ metricName: string; /** * The number of seconds of look back (from now) to query for tag data. * Default value is 14400 (4 hours), minimum value is 14400 (4 hours). * @type number */ windowSeconds?: number; /** * Filter results to tags from data points that have the specified tags. * For example, `filter[tags]=env:staging,host:123` returns tags only from data points with both `env:staging` and `host:123`. * @type string */ filterTags?: string; /** * Filter returned tags to those matching a substring. * For example, `filter[match]=env` returns tags like `env:prod`, `environment:staging`, etc. * @type string */ filterMatch?: string; /** * Whether to include tag values in the response. * Defaults to true. * @type boolean */ filterIncludeTagValues?: boolean; /** * Whether to allow partial results. * Defaults to false. * @type boolean */ filterAllowPartial?: boolean; /** * Maximum number of results to return. * @type number */ pageLimit?: number; } export interface MetricsApiListVolumesByMetricNameRequest { /** * The name of the metric. * @type string */ metricName: string; /** * The number of seconds of look back (from now). * Default value is 3,600 (1 hour), maximum value is 2,592,000 (1 month). * @type number */ windowSeconds?: number; } export interface MetricsApiQueryScalarDataRequest { /** * @type ScalarFormulaQueryRequest */ body: ScalarFormulaQueryRequest; } export interface MetricsApiQueryTimeseriesDataRequest { /** * @type TimeseriesFormulaQueryRequest */ body: TimeseriesFormulaQueryRequest; } export interface MetricsApiReorderTagIndexingRulesRequest { /** * @type TagIndexingRuleOrderRequest */ body: TagIndexingRuleOrderRequest; } export interface MetricsApiSubmitMetricsRequest { /** * @type MetricPayload */ body: MetricPayload; /** * HTTP header used to compress the media-type. * @type MetricContentEncoding */ contentEncoding?: MetricContentEncoding; } export interface MetricsApiUpdateTagConfigurationRequest { /** * The name of the metric. * @type string */ metricName: string; /** * @type MetricTagConfigurationUpdateRequest */ body: MetricTagConfigurationUpdateRequest; } export interface MetricsApiUpdateTagIndexingRuleRequest { /** * ID of the tag indexing rule. * @type string */ id: string; /** * @type TagIndexingRuleUpdateRequest */ body: TagIndexingRuleUpdateRequest; } export declare class MetricsApi { private requestFactory; private responseProcessor; private configuration; constructor(configuration: Configuration, requestFactory?: MetricsApiRequestFactory, responseProcessor?: MetricsApiResponseProcessor); /** * **Note**: This endpoint is deprecated. Use [Tag Indexing Rules](/api/latest/metrics/#create-a-tag-indexing-rule) (`POST /api/v2/metrics/tag-indexing-rules`) instead. * * 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. * @param param The request object */ createBulkTagsMetricsConfiguration(param: MetricsApiCreateBulkTagsMetricsConfigurationRequest, options?: Configuration): Promise<MetricBulkTagConfigResponse>; /** * 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. * @param param The request object */ createTagConfiguration(param: MetricsApiCreateTagConfigurationRequest, options?: Configuration): Promise<MetricTagConfigurationResponse>; /** * Create a tag indexing rule for the org. `rule_order` is assigned server-side as max+1 * among existing rules; use the reorder endpoint to change the evaluation order. * Requires the `Manage Tags for Metrics` permission. * @param param The request object */ createTagIndexingRule(param: MetricsApiCreateTagIndexingRuleRequest, options?: Configuration): Promise<TagIndexingRuleResponse>; /** * Exempt a metric from all tag indexing rules. The response includes the created * exemption resource. Requires the `Manage Tags for Metrics` permission. * @param param The request object */ createTagIndexingRuleExemption(param: MetricsApiCreateTagIndexingRuleExemptionRequest, options?: Configuration): Promise<TagIndexingRuleExemptionResponse>; /** * **Note**: This endpoint is deprecated. Use [Tag Indexing Rules](/api/latest/metrics/#create-a-tag-indexing-rule) (`POST /api/v2/metrics/tag-indexing-rules`) instead. * * 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. * @param param The request object */ deleteBulkTagsMetricsConfiguration(param: MetricsApiDeleteBulkTagsMetricsConfigurationRequest, options?: Configuration): Promise<MetricBulkTagConfigResponse>; /** * Deletes a metric's tag configuration. Can only be used with application * keys from users with the `Manage Tags for Metrics` permission. * Note: This operation is irreversible. * @param param The request object */ deleteTagConfiguration(param: MetricsApiDeleteTagConfigurationRequest, options?: Configuration): Promise<void>; /** * Soft-delete a tag indexing rule. Idempotent: returns 204 whether the rule existed or was already deleted. * Remaining rules in the org are automatically re-sequenced to keep `rule_order` dense and 1-based. * Requires the `Manage Tags for Metrics` permission. * @param param The request object */ deleteTagIndexingRule(param: MetricsApiDeleteTagIndexingRuleRequest, options?: Configuration): Promise<void>; /** * Remove a metric's exemption from tag indexing rules. Idempotent: returns 204 whether or not * an exemption existed. Any associated legacy tag configuration record is also removed. * Requires the `Manage Tags for Metrics` permission. * @param param The request object */ deleteTagIndexingRuleExemption(param: MetricsApiDeleteTagIndexingRuleExemptionRequest, options?: Configuration): Promise<void>; /** * Returns the estimated cardinality for a metric with a given tag, percentile and number of aggregations configuration using Metrics without Limits™. * @param param The request object */ estimateMetricsOutputSeries(param: MetricsApiEstimateMetricsOutputSeriesRequest, options?: Configuration): Promise<MetricEstimateResponse>; /** * Returns the cardinality details of tags for a specific metric. * @param param The request object */ getMetricTagCardinalityDetails(param: MetricsApiGetMetricTagCardinalityDetailsRequest, options?: Configuration): Promise<MetricTagCardinalitiesResponse>; /** * Get a single tag indexing rule by its UUID. * @param param The request object */ getTagIndexingRule(param: MetricsApiGetTagIndexingRuleRequest, options?: Configuration): Promise<TagIndexingRuleResponse>; /** * Returns why a metric is excluded from tag indexing rules. * Returns 200 with `kind=exemption` when an explicit exemption exists, 200 with * `kind=legacy_tag_configuration` when the metric has a legacy tag configuration acting as an * implicit exclusion, or 404 when neither applies. * @param param The request object */ getTagIndexingRuleExemption(param: MetricsApiGetTagIndexingRuleExemptionRequest, options?: Configuration): Promise<TagIndexingRuleExemptionResponse>; /** * List tags and aggregations that are actively queried on dashboards, notebooks, monitors, the Metrics Explorer, and using the API for a given metric name. * @param param The request object */ listActiveMetricConfigurations(param: MetricsApiListActiveMetricConfigurationsRequest, options?: Configuration): Promise<MetricSuggestedTagsAndAggregationsResponse>; /** * Returns dashboards, monitors, notebooks, and SLOs that a metric is stored in, if any. Updated every 24 hours. * @param param The request object */ listMetricAssets(param: MetricsApiListMetricAssetsRequest, options?: Configuration): Promise<MetricAssetsResponse>; /** * Returns the tag configuration for the given metric name. * @param param The request object */ listTagConfigurationByName(param: MetricsApiListTagConfigurationByNameRequest, options?: Configuration): Promise<MetricTagConfigurationResponse>; /** * Get a list of actively reporting metrics for your organization. Pagination is optional using the `page[cursor]` and `page[size]` query parameters. * * Query parameters use bracket notation (for example, `filter[tags]`, `filter[queried][window][seconds]`). Pass them as standard URL query strings, URL-encoding the brackets if your client does not handle them. For example: `GET /api/v2/metrics?filter[tags]=env:prod&window[seconds]=86400&page[size]=500`. * @param param The request object */ listTagConfigurations(param?: MetricsApiListTagConfigurationsRequest, options?: Configuration): Promise<MetricsAndMetricTagConfigurationsResponse>; /** * Provide a paginated version of listTagConfigurations returning a generator with all the items. */ listTagConfigurationsWithPagination(param?: MetricsApiListTagConfigurationsRequest, options?: Configuration): AsyncGenerator<MetricsAndMetricTagConfigurations>; /** * List tag indexing rules for an org, sorted by `rule_order`, with offset/limit pagination. * @param param The request object */ listTagIndexingRules(param?: MetricsApiListTagIndexingRulesRequest, options?: Configuration): Promise<TagIndexingRulesResponse>; /** * List the tag indexing rules that apply to a given metric, sorted by `rule_order`. * Matching is performed server-side using each rule's `metric_name_matches` glob patterns. * @param param The request object */ listTagIndexingRulesForMetric(param: MetricsApiListTagIndexingRulesForMetricRequest, options?: Configuration): Promise<TagIndexingRulesResponse>; /** * View indexed and ingested tags for a given metric name. * Results are filtered by the `window[seconds]` parameter, which defaults to 14400 (4 hours). * @param param The request object */ listTagsByMetricName(param: MetricsApiListTagsByMetricNameRequest, options?: Configuration): Promise<MetricAllTagsResponse>; /** * View hourly average cardinality for the given metric name over the look back period. * For Metric Name Pricing customers, view total point volume for the given metric name * over the look back period. * @param param The request object */ listVolumesByMetricName(param: MetricsApiListVolumesByMetricNameRequest, options?: Configuration): Promise<MetricVolumesResponse>; /** * 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. * @param param The request object */ queryScalarData(param: MetricsApiQueryScalarDataRequest, options?: Configuration): Promise<ScalarFormulaQueryResponse>; /** * Query timeseries data across various data sources and * process the data by applying formulas and functions. * @param param The request object */ queryTimeseriesData(param: MetricsApiQueryTimeseriesDataRequest, options?: Configuration): Promise<TimeseriesFormulaQueryResponse>; /** * Atomically re-sequence the tag indexing rules for an org to match the supplied list of rule UUIDs. * The server assigns `rule_order` 1, 2, … matching each rule UUID by position in the list. * Requires the `Manage Tags for Metrics` permission. * @param param The request object */ reorderTagIndexingRules(param: MetricsApiReorderTagIndexingRulesRequest, options?: Configuration): Promise<void>; /** * 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. * @param param The request object */ submitMetrics(param: MetricsApiSubmitMetricsRequest, options?: Configuration): Promise<IntakePayloadAccepted>; /** * 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. * @param param The request object */ updateTagConfiguration(param: MetricsApiUpdateTagConfigurationRequest, options?: Configuration): Promise<MetricTagConfigurationResponse>; /** * Partially update a tag indexing rule. Fields omitted from the request body are left unchanged. * Setting `rule_order` to a value already used by another rule returns 409; use the * reorder endpoint for atomic re-sequencing. Requires the `Manage Tags for Metrics` permission. * @param param The request object */ updateTagIndexingRule(param: MetricsApiUpdateTagIndexingRuleRequest, options?: Configuration): Promise<TagIndexingRuleResponse>; }