PHPFUI/InstaDoc
 
Copied!

Defines a metric type and its schema. Once a metric descriptor is created, deleting or altering it stops data collection and makes the metric type's existing data unusable.

Generated from protobuf message google.api.MetricDescriptor

CloneableInstantiable
Methods
public __construct( $data = NULL)
 

Constructor.

  • param array $data { Optional. Data for populating the Message object. 
    @type string $name
      The resource name of the metric descriptor.
@type string $type
      The metric type, including its DNS name prefix. The type is not
      URL-encoded. All user-defined metric types have the DNS name
      `custom.googleapis.com` or `external.googleapis.com`. Metric types should
      use a natural hierarchical grouping. For example:
          "custom.googleapis.com/invoice/paid/amount"
          "external.googleapis.com/prometheus/up"
          "appengine.googleapis.com/http/server/response_latencies"
@type array<\Google\Api\LabelDescriptor>|\Google\Protobuf\Internal\RepeatedField $labels
      The set of labels that can be used to describe a specific
      instance of this metric type. For example, the
      `appengine.googleapis.com/http/server/response_latencies` metric
      type has a label for the HTTP response code, `response_code`, so
      you can look at latencies for successful responses or just
      for responses that failed.
@type int $metric_kind
      Whether the metric records instantaneous values, changes to a value, etc.
      Some combinations of `metric_kind` and `value_type` might not be supported.
@type int $value_type
      Whether the measurement is an integer, a floating-point number, etc.
      Some combinations of `metric_kind` and `value_type` might not be supported.
@type string $unit
      The units in which the metric value is reported. It is only applicable
      if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The `unit`
      defines the representation of the stored metric values.
      Different systems might scale the values to be more easily displayed (so a
      value of `0.02kBy` _might_ be displayed as `20By`, and a value of
      `3523kBy` _might_ be displayed as `3.5MBy`). However, if the `unit` is
      `kBy`, then the value of the metric is always in thousands of bytes, no
      matter how it might be displayed.
      If you want a custom metric to record the exact number of CPU-seconds used
      by a job, you can create an `INT64 CUMULATIVE` metric whose `unit` is
      `s{CPU}` (or equivalently `1s{CPU}` or just `s`). If the job uses 12,005
      CPU-seconds, then the value is written as `12005`.
      Alternatively, if you want a custom metric to record data in a more
      granular way, you can create a `DOUBLE CUMULATIVE` metric whose `unit` is
      `ks{CPU}`, and then write the value `12.005` (which is `12005/1000`),
      or use `Kis{CPU}` and write `11.723` (which is `12005/1024`).
      The supported units are a subset of [The Unified Code for Units of
      Measure](https://unitsofmeasure.org/ucum.html) standard:
      **Basic units (UNIT)**
      *          * `bit`   bit
      *          * `By`    byte
      *          * `s`     second
      *          * `min`   minute
      *          * `h`     hour
      *          * `d`     day
      *          * `1`     dimensionless
      **Prefixes (PREFIX)**
      *          * `k`     kilo    (10^3)
      *          * `M`     mega    (10^6)
      *          * `G`     giga    (10^9)
      *          * `T`     tera    (10^12)
      *          * `P`     peta    (10^15)
      *          * `E`     exa     (10^18)
      *          * `Z`     zetta   (10^21)
      *          * `Y`     yotta   (10^24)
      *          * `m`     milli   (10^-3)
      *          * `u`     micro   (10^-6)
      *          * `n`     nano    (10^-9)
      *          * `p`     pico    (10^-12)
      *          * `f`     femto   (10^-15)
      *          * `a`     atto    (10^-18)
      *          * `z`     zepto   (10^-21)
      *          * `y`     yocto   (10^-24)
      *          * `Ki`    kibi    (2^10)
      *          * `Mi`    mebi    (2^20)
      *          * `Gi`    gibi    (2^30)
      *          * `Ti`    tebi    (2^40)
      *          * `Pi`    pebi    (2^50)
      **Grammar**
      The grammar also includes these connectors:
      *          * `/`    division or ratio (as an infix operator). For examples,
               `kBy/{email}` or `MiBy/10ms` (although you should almost never
               have `/s` in a metric `unit`; rates should always be computed at
               query time from the underlying cumulative or delta value).
      *          * `.`    multiplication or composition (as an infix operator). For
               examples, `GBy.d` or `k{watt}.h`.
      The grammar for a unit is as follows:
          Expression = Component { "." Component } { "/" Component } ;
          Component = ( [ PREFIX ] UNIT | "%" ) [ Annotation ]
                    | Annotation
                    | "1"
                    ;
          Annotation = "{" NAME "}" ;
      Notes:
      *          * `Annotation` is just a comment if it follows a `UNIT`. If the annotation
         is used alone, then the unit is equivalent to `1`. For examples,
         `{request}/s == 1/s`, `By{transmitted}/s == By/s`.
      *          * `NAME` is a sequence of non-blank printable ASCII characters not
         containing `{` or `}`.
      *          * `1` represents a unitary [dimensionless
         unit](https://en.wikipedia.org/wiki/Dimensionless_quantity) of 1, such
         as in `1/s`. It is typically used when none of the basic units are
         appropriate. For example, "new users per day" can be represented as
         `1/d` or `{new-users}/d` (and a metric value `5` would mean "5 new
         users). Alternatively, "thousands of page views per day" would be
         represented as `1000/d` or `k1/d` or `k{page_views}/d` (and a metric
         value of `5.3` would mean "5300 page views per day").
      * `%` represents dimensionless value of 1/100, and annotates values giving
         a percentage (so the metric values are typically in the range of 0..100,
         and a metric value `3` means "3 percent").
      * `10^2.%` indicates a metric contains a ratio, typically in the range
         0..1, that will be multiplied by 100 and displayed as a percentage
         (so a metric value `0.03` means "3 percent").
@type string $description
      A detailed description of the metric, which can be used in documentation.
@type string $display_name
      A concise name for the metric, which can be displayed in user interfaces.
      Use sentence case without an ending period, for example "Request count".
      This field is optional but it is recommended to be set for any metrics
      associated with user-visible concepts, such as Quota.
@type \Google\Api\MetricDescriptor\MetricDescriptorMetadata $metadata
      Optional. Metadata which can be used to guide usage of the metric.
@type int $launch_stage
      Optional. The launch stage of the metric definition.
@type array<string>|\Google\Protobuf\Internal\RepeatedField $monitored_resource_types
      Read-only. If present, then a [time
      series][google.monitoring.v3.TimeSeries], which is identified partially by
      a metric type and a
      [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor], that
      is associated with this metric type can only be associated with one of the
      monitored resource types listed here.
    }
public Google\Protobuf\Internal\Message::__debugInfo()
public Google\Protobuf\Internal\Message::byteSize()
 
  • ignore
public Google\Protobuf\Internal\Message::clear()
 

Clear all containing fields.

  • return null
public clearMetadata()
public Google\Protobuf\Internal\Message::discardUnknownFields()
 

Clear all unknown fields previously parsed.

  • return null
public getDescription()
 

A detailed description of the metric, which can be used in documentation.

Generated from protobuf field string description = 6;

  • return string
public getDisplayName()
 

A concise name for the metric, which can be displayed in user interfaces.

Use sentence case without an ending period, for example "Request count". This field is optional but it is recommended to be set for any metrics associated with user-visible concepts, such as Quota.

Generated from protobuf field string display_name = 7;

  • return string
public getLabels()
 

The set of labels that can be used to describe a specific instance of this metric type. For example, the appengine.googleapis.com/http/server/response_latencies metric type has a label for the HTTP response code, response_code, so you can look at latencies for successful responses or just for responses that failed.

Generated from protobuf field repeated .google.api.LabelDescriptor labels = 2;

  • return \Google\Protobuf\Internal\RepeatedField
public getLaunchStage()
 

Optional. The launch stage of the metric definition.

Generated from protobuf field .google.api.LaunchStage launch_stage = 12;

  • return int
public getMetadata()
 

Optional. Metadata which can be used to guide usage of the metric.

Generated from protobuf field .google.api.MetricDescriptor.MetricDescriptorMetadata metadata = 10;

  • return \Google\Api\MetricDescriptor\MetricDescriptorMetadata|null
public getMetricKind()
 

Whether the metric records instantaneous values, changes to a value, etc.

Some combinations of metric_kind and value_type might not be supported.

Generated from protobuf field .google.api.MetricDescriptor.MetricKind metric_kind = 3;

  • return int
public getMonitoredResourceTypes()
 

Read-only. If present, then a [time series][google.monitoring.v3.TimeSeries], which is identified partially by a metric type and a [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor], that is associated with this metric type can only be associated with one of the monitored resource types listed here.

Generated from protobuf field repeated string monitored_resource_types = 13;

  • return \Google\Protobuf\Internal\RepeatedField
public getName()
 

The resource name of the metric descriptor.

Generated from protobuf field string name = 1;

  • return string
public getType()
 

The metric type, including its DNS name prefix. The type is not URL-encoded. All user-defined metric types have the DNS name custom.googleapis.com or external.googleapis.com. Metric types should use a natural hierarchical grouping. For example: "custom.googleapis.com/invoice/paid/amount" "external.googleapis.com/prometheus/up" "appengine.googleapis.com/http/server/response_latencies"

Generated from protobuf field string type = 8;

  • return string
public getUnit()
 

The units in which the metric value is reported. It is only applicable if the value_type is INT64, DOUBLE, or DISTRIBUTION. The unit defines the representation of the stored metric values.

Different systems might scale the values to be more easily displayed (so a value of 0.02kBy might be displayed as 20By, and a value of 3523kBy might be displayed as 3.5MBy). However, if the unit is kBy, then the value of the metric is always in thousands of bytes, no matter how it might be displayed. If you want a custom metric to record the exact number of CPU-seconds used by a job, you can create an INT64 CUMULATIVE metric whose unit is s{CPU} (or equivalently 1s{CPU} or just s). If the job uses 12,005 CPU-seconds, then the value is written as 12005. Alternatively, if you want a custom metric to record data in a more granular way, you can create a DOUBLE CUMULATIVE metric whose unit is ks{CPU}, and then write the value 12.005 (which is 12005/1000), or use Kis{CPU} and write 11.723 (which is 12005/1024). The supported units are a subset of The Unified Code for Units of Measure standard: Basic units (UNIT)

  • bit bit
  • By byte
  • s second
  • min minute
  • h hour
  • d day
  • 1 dimensionless Prefixes (PREFIX)
  • k kilo (10^3)
  • M mega (10^6)
  • G giga (10^9)
  • T tera (10^12)
  • P peta (10^15)
  • E exa (10^18)
  • Z zetta (10^21)
  • Y yotta (10^24)
  • m milli (10^-3)
  • u micro (10^-6)
  • n nano (10^-9)
  • p pico (10^-12)
  • f femto (10^-15)
  • a atto (10^-18)
  • z zepto (10^-21)
  • y yocto (10^-24)
  • Ki kibi (2^10)
  • Mi mebi (2^20)
  • Gi gibi (2^30)
  • Ti tebi (2^40)
  • Pi pebi (2^50) Grammar The grammar also includes these connectors:
  • / division or ratio (as an infix operator). For examples, kBy/{email} or MiBy/10ms (although you should almost never have /s in a metric unit; rates should always be computed at query time from the underlying cumulative or delta value).
  • . multiplication or composition (as an infix operator). For examples, GBy.d or k{watt}.h. The grammar for a unit is as follows: Expression = Component { "." Component } { "/" Component } ; Component = ( [ PREFIX ] UNIT | "%" ) [ Annotation ] | Annotation | "1" ; Annotation = "{" NAME "}" ; Notes:
  • Annotation is just a comment if it follows a UNIT. If the annotation is used alone, then the unit is equivalent to 1. For examples, {request}/s == 1/s, By{transmitted}/s == By/s.
  • NAME is a sequence of non-blank printable ASCII characters not containing { or }.
  • 1 represents a unitary dimensionless unit of 1, such as in 1/s. It is typically used when none of the basic units are appropriate. For example, "new users per day" can be represented as 1/d or {new-users}/d (and a metric value 5 would mean "5 new users). Alternatively, "thousands of page views per day" would be represented as 1000/d or k1/d or k{page_views}/d (and a metric value of 5.3 would mean "5300 page views per day").
  • % represents dimensionless value of 1/100, and annotates values giving a percentage (so the metric values are typically in the range of 0..100, and a metric value 3 means "3 percent").
  • 10^2.% indicates a metric contains a ratio, typically in the range 0..1, that will be multiplied by 100 and displayed as a percentage (so a metric value 0.03 means "3 percent").

Generated from protobuf field string unit = 5;

  • return string
public getValueType()
 

Whether the measurement is an integer, a floating-point number, etc.

Some combinations of metric_kind and value_type might not be supported.

Generated from protobuf field .google.api.MetricDescriptor.ValueType value_type = 4;

  • return int
public hasMetadata()
public Google\Protobuf\Internal\Message::jsonByteSize( $options = 0)
 
  • ignore
public Google\Protobuf\Internal\Message::mergeFrom( $msg)
 

Merges the contents of the specified message into current message.

This method merges the contents of the specified message into the current message. Singular fields that are set in the specified message overwrite the corresponding fields in the current message. Repeated fields are appended. Map fields key-value pairs are overwritten. Singular/Oneof sub-messages are recursively merged. All overwritten sub-messages are deep-copied.

  • param object $msg Protobuf message to be merged from.
  • return null
public Google\Protobuf\Internal\Message::mergeFromJsonString( $data, $ignore_unknown = false)
 

Parses a json string to protobuf message.

This function takes a string in the json wire format, matching the encoding output by serializeToJsonString(). See mergeFrom() for merging behavior, if the field is already set in the specified message.

  • param string $data Json protobuf data.
  • param bool $ignore_unknown
  • return null
  • throws \Exception Invalid data.
public Google\Protobuf\Internal\Message::mergeFromString( $data)
 

Parses a protocol buffer contained in a string.

This function takes a string in the (non-human-readable) binary wire format, matching the encoding output by serializeToString(). See mergeFrom() for merging behavior, if the field is already set in the specified message.

  • param string $data Binary protobuf data.
  • return null
  • throws \Exception Invalid data.
public Google\Protobuf\Internal\Message::parseFromJsonStream( $input, $ignore_unknown)
 
  • ignore
public Google\Protobuf\Internal\Message::parseFromStream( $input)
 
  • ignore
public Google\Protobuf\Internal\Message::serializeToJsonStream( $output)
 
  • ignore
public Google\Protobuf\Internal\Message::serializeToJsonString( $options = 0)
 

Serialize the message to json string.

  • return string Serialized json protobuf data.
public Google\Protobuf\Internal\Message::serializeToStream( $output)
 
  • ignore
public Google\Protobuf\Internal\Message::serializeToString()
 

Serialize the message to string.

  • return string Serialized binary protobuf data.
public setDescription( $var)
 

A detailed description of the metric, which can be used in documentation.

Generated from protobuf field string description = 6;

  • param string $var
  • return $this
public setDisplayName( $var)
 

A concise name for the metric, which can be displayed in user interfaces.

Use sentence case without an ending period, for example "Request count". This field is optional but it is recommended to be set for any metrics associated with user-visible concepts, such as Quota.

Generated from protobuf field string display_name = 7;

  • param string $var
  • return $this
public setLabels( $var)
 

The set of labels that can be used to describe a specific instance of this metric type. For example, the appengine.googleapis.com/http/server/response_latencies metric type has a label for the HTTP response code, response_code, so you can look at latencies for successful responses or just for responses that failed.

Generated from protobuf field repeated .google.api.LabelDescriptor labels = 2;

  • param \Google\Api\LabelDescriptor[]|\Google\Protobuf\Internal\RepeatedField $var
  • return $this
public setLaunchStage( $var)
 

Optional. The launch stage of the metric definition.

Generated from protobuf field .google.api.LaunchStage launch_stage = 12;

  • param int $var
  • return $this
public setMetadata( $var)
 

Optional. Metadata which can be used to guide usage of the metric.

Generated from protobuf field .google.api.MetricDescriptor.MetricDescriptorMetadata metadata = 10;

  • param \Google\Api\MetricDescriptor\MetricDescriptorMetadata $var
  • return $this
public setMetricKind( $var)
 

Whether the metric records instantaneous values, changes to a value, etc.

Some combinations of metric_kind and value_type might not be supported.

Generated from protobuf field .google.api.MetricDescriptor.MetricKind metric_kind = 3;

  • param int $var
  • return $this
public setMonitoredResourceTypes( $var)
 

Read-only. If present, then a [time series][google.monitoring.v3.TimeSeries], which is identified partially by a metric type and a [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor], that is associated with this metric type can only be associated with one of the monitored resource types listed here.

Generated from protobuf field repeated string monitored_resource_types = 13;

  • param string[]|\Google\Protobuf\Internal\RepeatedField $var
  • return $this
public setName( $var)
 

The resource name of the metric descriptor.

Generated from protobuf field string name = 1;

  • param string $var
  • return $this
public setType( $var)
 

The metric type, including its DNS name prefix. The type is not URL-encoded. All user-defined metric types have the DNS name custom.googleapis.com or external.googleapis.com. Metric types should use a natural hierarchical grouping. For example: "custom.googleapis.com/invoice/paid/amount" "external.googleapis.com/prometheus/up" "appengine.googleapis.com/http/server/response_latencies"

Generated from protobuf field string type = 8;

  • param string $var
  • return $this
public setUnit( $var)
 

The units in which the metric value is reported. It is only applicable if the value_type is INT64, DOUBLE, or DISTRIBUTION. The unit defines the representation of the stored metric values.

Different systems might scale the values to be more easily displayed (so a value of 0.02kBy might be displayed as 20By, and a value of 3523kBy might be displayed as 3.5MBy). However, if the unit is kBy, then the value of the metric is always in thousands of bytes, no matter how it might be displayed. If you want a custom metric to record the exact number of CPU-seconds used by a job, you can create an INT64 CUMULATIVE metric whose unit is s{CPU} (or equivalently 1s{CPU} or just s). If the job uses 12,005 CPU-seconds, then the value is written as 12005. Alternatively, if you want a custom metric to record data in a more granular way, you can create a DOUBLE CUMULATIVE metric whose unit is ks{CPU}, and then write the value 12.005 (which is 12005/1000), or use Kis{CPU} and write 11.723 (which is 12005/1024). The supported units are a subset of The Unified Code for Units of Measure standard: Basic units (UNIT)

  • bit bit
  • By byte
  • s second
  • min minute
  • h hour
  • d day
  • 1 dimensionless Prefixes (PREFIX)
  • k kilo (10^3)
  • M mega (10^6)
  • G giga (10^9)
  • T tera (10^12)
  • P peta (10^15)
  • E exa (10^18)
  • Z zetta (10^21)
  • Y yotta (10^24)
  • m milli (10^-3)
  • u micro (10^-6)
  • n nano (10^-9)
  • p pico (10^-12)
  • f femto (10^-15)
  • a atto (10^-18)
  • z zepto (10^-21)
  • y yocto (10^-24)
  • Ki kibi (2^10)
  • Mi mebi (2^20)
  • Gi gibi (2^30)
  • Ti tebi (2^40)
  • Pi pebi (2^50) Grammar The grammar also includes these connectors:
  • / division or ratio (as an infix operator). For examples, kBy/{email} or MiBy/10ms (although you should almost never have /s in a metric unit; rates should always be computed at query time from the underlying cumulative or delta value).
  • . multiplication or composition (as an infix operator). For examples, GBy.d or k{watt}.h. The grammar for a unit is as follows: Expression = Component { "." Component } { "/" Component } ; Component = ( [ PREFIX ] UNIT | "%" ) [ Annotation ] | Annotation | "1" ; Annotation = "{" NAME "}" ; Notes:
  • Annotation is just a comment if it follows a UNIT. If the annotation is used alone, then the unit is equivalent to 1. For examples, {request}/s == 1/s, By{transmitted}/s == By/s.
  • NAME is a sequence of non-blank printable ASCII characters not containing { or }.
  • 1 represents a unitary dimensionless unit of 1, such as in 1/s. It is typically used when none of the basic units are appropriate. For example, "new users per day" can be represented as 1/d or {new-users}/d (and a metric value 5 would mean "5 new users). Alternatively, "thousands of page views per day" would be represented as 1000/d or k1/d or k{page_views}/d (and a metric value of 5.3 would mean "5300 page views per day").
  • % represents dimensionless value of 1/100, and annotates values giving a percentage (so the metric values are typically in the range of 0..100, and a metric value 3 means "3 percent").
  • 10^2.% indicates a metric contains a ratio, typically in the range 0..1, that will be multiplied by 100 and displayed as a percentage (so a metric value 0.03 means "3 percent").

Generated from protobuf field string unit = 5;

  • param string $var
  • return $this
public setValueType( $var)
 

Whether the measurement is an integer, a floating-point number, etc.

Some combinations of metric_kind and value_type might not be supported.

Generated from protobuf field .google.api.MetricDescriptor.ValueType value_type = 4;

  • param int $var
  • return $this
Properties
protected $description = ''
 

A detailed description of the metric, which can be used in documentation.

Generated from protobuf field string description = 6;

protected $display_name = ''
 

A concise name for the metric, which can be displayed in user interfaces.

Use sentence case without an ending period, for example "Request count". This field is optional but it is recommended to be set for any metrics associated with user-visible concepts, such as Quota.

Generated from protobuf field string display_name = 7;

protected $launch_stage = 0
 

Optional. The launch stage of the metric definition.

Generated from protobuf field .google.api.LaunchStage launch_stage = 12;

protected $metadata = NULL
 

Optional. Metadata which can be used to guide usage of the metric.

Generated from protobuf field .google.api.MetricDescriptor.MetricDescriptorMetadata metadata = 10;

protected $metric_kind = 0
 

Whether the metric records instantaneous values, changes to a value, etc.

Some combinations of metric_kind and value_type might not be supported.

Generated from protobuf field .google.api.MetricDescriptor.MetricKind metric_kind = 3;

protected $name = ''
 

The resource name of the metric descriptor.

Generated from protobuf field string name = 1;

protected $type = ''
 

The metric type, including its DNS name prefix. The type is not URL-encoded. All user-defined metric types have the DNS name custom.googleapis.com or external.googleapis.com. Metric types should use a natural hierarchical grouping. For example: "custom.googleapis.com/invoice/paid/amount" "external.googleapis.com/prometheus/up" "appengine.googleapis.com/http/server/response_latencies"

Generated from protobuf field string type = 8;

protected $unit = ''
 

The units in which the metric value is reported. It is only applicable if the value_type is INT64, DOUBLE, or DISTRIBUTION. The unit defines the representation of the stored metric values.

Different systems might scale the values to be more easily displayed (so a value of 0.02kBy might be displayed as 20By, and a value of 3523kBy might be displayed as 3.5MBy). However, if the unit is kBy, then the value of the metric is always in thousands of bytes, no matter how it might be displayed. If you want a custom metric to record the exact number of CPU-seconds used by a job, you can create an INT64 CUMULATIVE metric whose unit is s{CPU} (or equivalently 1s{CPU} or just s). If the job uses 12,005 CPU-seconds, then the value is written as 12005. Alternatively, if you want a custom metric to record data in a more granular way, you can create a DOUBLE CUMULATIVE metric whose unit is ks{CPU}, and then write the value 12.005 (which is 12005/1000), or use Kis{CPU} and write 11.723 (which is 12005/1024). The supported units are a subset of The Unified Code for Units of Measure standard: Basic units (UNIT)

  • bit bit
  • By byte
  • s second
  • min minute
  • h hour
  • d day
  • 1 dimensionless Prefixes (PREFIX)
  • k kilo (10^3)
  • M mega (10^6)
  • G giga (10^9)
  • T tera (10^12)
  • P peta (10^15)
  • E exa (10^18)
  • Z zetta (10^21)
  • Y yotta (10^24)
  • m milli (10^-3)
  • u micro (10^-6)
  • n nano (10^-9)
  • p pico (10^-12)
  • f femto (10^-15)
  • a atto (10^-18)
  • z zepto (10^-21)
  • y yocto (10^-24)
  • Ki kibi (2^10)
  • Mi mebi (2^20)
  • Gi gibi (2^30)
  • Ti tebi (2^40)
  • Pi pebi (2^50) Grammar The grammar also includes these connectors:
  • / division or ratio (as an infix operator). For examples, kBy/{email} or MiBy/10ms (although you should almost never have /s in a metric unit; rates should always be computed at query time from the underlying cumulative or delta value).
  • . multiplication or composition (as an infix operator). For examples, GBy.d or k{watt}.h. The grammar for a unit is as follows: Expression = Component { "." Component } { "/" Component } ; Component = ( [ PREFIX ] UNIT | "%" ) [ Annotation ] | Annotation | "1" ; Annotation = "{" NAME "}" ; Notes:
  • Annotation is just a comment if it follows a UNIT. If the annotation is used alone, then the unit is equivalent to 1. For examples, {request}/s == 1/s, By{transmitted}/s == By/s.
  • NAME is a sequence of non-blank printable ASCII characters not containing { or }.
  • 1 represents a unitary dimensionless unit of 1, such as in 1/s. It is typically used when none of the basic units are appropriate. For example, "new users per day" can be represented as 1/d or {new-users}/d (and a metric value 5 would mean "5 new users). Alternatively, "thousands of page views per day" would be represented as 1000/d or k1/d or k{page_views}/d (and a metric value of 5.3 would mean "5300 page views per day").
  • % represents dimensionless value of 1/100, and annotates values giving a percentage (so the metric values are typically in the range of 0..100, and a metric value 3 means "3 percent").
  • 10^2.% indicates a metric contains a ratio, typically in the range 0..1, that will be multiplied by 100 and displayed as a percentage (so a metric value 0.03 means "3 percent").

Generated from protobuf field string unit = 5;

protected $value_type = 0
 

Whether the measurement is an integer, a floating-point number, etc.

Some combinations of metric_kind and value_type might not be supported.

Generated from protobuf field .google.api.MetricDescriptor.ValueType value_type = 4;

Methods
protected Google\Protobuf\Internal\Message::hasOneof( $number)
protected Google\Protobuf\Internal\Message::mergeFromArray(array $array)
 

Populates the message from a user-supplied PHP array. Array keys correspond to Message properties and nested message properties.

Example:

$message->mergeFromArray([
    'name' => 'This is a message name',
    'interval' => [
         'startTime' => time() - 60,
         'endTime' => time(),
    ]
]);

This method will trigger an error if it is passed data that cannot be converted to the correct type. For example, a StringValue field must receive data that is either a string or a StringValue object.

  • param array $array An array containing message properties and values.
  • return null
protected Google\Protobuf\Internal\Message::mergeFromJsonArray( $array, $ignore_unknown)
protected Google\Protobuf\Internal\Message::readOneof( $number)
protected Google\Protobuf\Internal\Message::readWrapperValue( $member)
protected Google\Protobuf\Internal\Message::whichOneof( $oneof_name)
protected Google\Protobuf\Internal\Message::writeOneof( $number, $value)
protected Google\Protobuf\Internal\Message::writeWrapperValue( $member, $value)
Properties
private $labels = NULL
 

The set of labels that can be used to describe a specific instance of this metric type. For example, the appengine.googleapis.com/http/server/response_latencies metric type has a label for the HTTP response code, response_code, so you can look at latencies for successful responses or just for responses that failed.

Generated from protobuf field repeated .google.api.LabelDescriptor labels = 2;

private $monitored_resource_types = NULL
 

Read-only. If present, then a [time series][google.monitoring.v3.TimeSeries], which is identified partially by a metric type and a [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor], that is associated with this metric type can only be associated with one of the monitored resource types listed here.

Generated from protobuf field repeated string monitored_resource_types = 13;

© 2025 Bruce Wells
Search Namespaces \ Classes
Configuration