> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chronosphere.io/llms.txt
> Use this file to discover all available pages before exploring further.

# ReadMetricMetadata

> Metric Metadata



## OpenAPI

````yaml openapi/api_v1_data_openapi3_DOCUMENTATION_ONLY.json GET /api/v1/data/metrics:metadata/{metric_name}
openapi: 3.0.3
info:
  description: |

    The Data API provides HTTP/JSON REST endpoints for reading and writing data
    to the Chronosphere system.

    Use this link to download the raw Swagger specification:
    <a href="/api/v1/data/swagger.json">/api/v1/data/swagger.json</a>
  title: Data V1 API
  version: v1
servers:
  - url: https://{tenant}.chronosphere.io
    variables:
      tenant:
        default: tenant
        description: tenant ID assigned by the service provider
security:
  - ApiKeyAuth: []
tags:
  - name: DataV1
paths:
  /api/v1/data/metrics:metadata/{metric_name}:
    get:
      tags:
        - DataV1
      description: Metric Metadata
      operationId: ReadMetricMetadata
      parameters:
        - description: The name of the metric to retrieve metadata for.
          in: path
          name: metric_name
          required: true
          schema:
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/datav1ReadMetricMetadataResponse'
          description: A successful response.
        default:
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/googlerpcStatus'
          description: An unexpected error response.
components:
  schemas:
    datav1ReadMetricMetadataResponse:
      description: >-
        ReadMetricMetadataResponse contains the metadata for the requested
        metric.
      properties:
        metadata:
          allOf:
            - $ref: '#/components/schemas/datav1MetricMetadata'
          description: The metadata for the requested metric.
      type: object
    googlerpcStatus:
      properties:
        code:
          format: int32
          type: integer
        details:
          items:
            $ref: '#/components/schemas/protobufAny'
          type: array
        message:
          type: string
      type: object
    datav1MetricMetadata:
      description: MetricMetadata contains metadata information about a metric.
      properties:
        description:
          description: Human-readable description of what the metric measures.
          type: string
        name:
          description: The name of the metric.
          type: string
        source:
          $ref: '#/components/schemas/datav1Source'
        type:
          allOf:
            - $ref: '#/components/schemas/datav1MetricType'
          description: The type of the metric (counter, gauge, etc.).
      type: object
    protobufAny:
      additionalProperties: {}
      properties:
        '@type':
          type: string
      type: object
    datav1Source:
      description: >-
        Source is the wire format used to ingest the metric (maps to the
        __metric_source__ synthetic label).

        Metrics predating CanonicalSource tracking will have UNSPECIFIED.
      enum:
        - PROMETHEUS
        - STATSD
        - OPEN_METRICS
        - CARBON
        - OPEN_TELEMETRY
        - SIGNALFX
        - WAVEFRONT
        - DOGSTATSD
        - CHRONO_GCP
        - CLOUDWATCH_METRIC_STREAM
        - CHRONO_AZURE
        - TAGGED_STATSD
        - CHRONO_CLOUDFLARE
        - CHRONO_INTEGRATION
      type: string
    datav1MetricType:
      description: >-
        MetricType defines the canonical metric types supported by the platform.

         - CUMULATIVE_COUNTER: A Prom-style cumulative counter, which stores a strictly increasing count
        of distinct events (but may reset to zero). Each datapoint stores the

        running total at the given timestamp.
         - GAUGE: A true gauge, which stores an observation of state at a point in time,
        where it is impossible to have two different states at a single point in

        time. Each datapoint stores the value at the given timestamp.
         - DELTA_COUNTER: A delta counter, which stores the same type of data as COUNTER, but where
        each datapoint stores a strictly positive delta increment at the given

        timestamp.
         - MEASUREMENT: A raw observation with some discrete value, e.g. individual request
        latency, individual request size, etc. Unlike a counter, each
        MEASUREMENT

        event has a discrete value. And unlike a gauge, there can be multiple

        values at any point in time.
         - CUMULATIVE_EXPONENTIAL_HISTOGRAM: An exponential histogram, where each datapoint is a structured value (not a
        float), which stores compressed buckets of cumulative measurement
        counts,

        along with total sum and count.
         - DELTA_EXPONENTIAL_HISTOGRAM: An exponential histogram, where each datapoint is a structured value (not a
        float), which stores compressed buckets of measurement count deltas,

        along with total sum and count.
      enum:
        - CUMULATIVE_COUNTER
        - GAUGE
        - DELTA_COUNTER
        - MEASUREMENT
        - CUMULATIVE_EXPONENTIAL_HISTOGRAM
        - DELTA_EXPONENTIAL_HISTOGRAM
      type: string
  securitySchemes:
    ApiKeyAuth:
      description: Chronosphere API token
      in: header
      name: API-Token
      type: apiKey

````