# frozen_string_literal: true

# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Auto-generated by gapic-generator-ruby. DO NOT EDIT!


module Google
  module Cloud
    module Monitoring
      module Dashboard
        module V1
          # Describes how to combine multiple time series to provide a different view of
          # the data.  Aggregation of time series is done in two steps. First, each time
          # series in the set is _aligned_ to the same time interval boundaries, then the
          # set of time series is optionally _reduced_ in number.
          #
          # Alignment consists of applying the `per_series_aligner` operation
          # to each time series after its data has been divided into regular
          # `alignment_period` time intervals. This process takes _all_ of the data
          # points in an alignment period, applies a mathematical transformation such as
          # averaging, minimum, maximum, delta, etc., and converts them into a single
          # data point per period.
          #
          # Reduction is when the aligned and transformed time series can optionally be
          # combined, reducing the number of time series through similar mathematical
          # transformations. Reduction involves applying a `cross_series_reducer` to
          # all the time series, optionally sorting the time series into subsets with
          # `group_by_fields`, and applying the reducer to each subset.
          #
          # The raw time series data can contain a huge amount of information from
          # multiple sources. Alignment and reduction transforms this mass of data into
          # a more manageable and representative collection of data, for example "the
          # 95% latency across the average of all tasks in a cluster". This
          # representative data can be more easily graphed and comprehended, and the
          # individual time series data is still available for later drilldown. For more
          # details, see [Filtering and
          # aggregation](https://cloud.google.com/monitoring/api/v3/aggregation).
          # @!attribute [rw] alignment_period
          #   @return [::Google::Protobuf::Duration]
          #     The `alignment_period` specifies a time interval, in seconds, that is used
          #     to divide the data in all the
          #     [time series][google.monitoring.v3.TimeSeries] into consistent blocks of
          #     time. This will be done before the per-series aligner can be applied to
          #     the data.
          #
          #     The value must be at least 60 seconds. If a per-series aligner other than
          #     `ALIGN_NONE` is specified, this field is required or an error is returned.
          #     If no per-series aligner is specified, or the aligner `ALIGN_NONE` is
          #     specified, then this field is ignored.
          #
          #     The maximum value of the `alignment_period` is 2 years, or 104 weeks.
          # @!attribute [rw] per_series_aligner
          #   @return [::Google::Cloud::Monitoring::Dashboard::V1::Aggregation::Aligner]
          #     An `Aligner` describes how to bring the data points in a single
          #     time series into temporal alignment. Except for `ALIGN_NONE`, all
          #     alignments cause all the data points in an `alignment_period` to be
          #     mathematically grouped together, resulting in a single data point for
          #     each `alignment_period` with end timestamp at the end of the period.
          #
          #     Not all alignment operations may be applied to all time series. The valid
          #     choices depend on the `metric_kind` and `value_type` of the original time
          #     series. Alignment can change the `metric_kind` or the `value_type` of
          #     the time series.
          #
          #     Time series data must be aligned in order to perform cross-time
          #     series reduction. If `cross_series_reducer` is specified, then
          #     `per_series_aligner` must be specified and not equal to `ALIGN_NONE`
          #     and `alignment_period` must be specified; otherwise, an error is
          #     returned.
          # @!attribute [rw] cross_series_reducer
          #   @return [::Google::Cloud::Monitoring::Dashboard::V1::Aggregation::Reducer]
          #     The reduction operation to be used to combine time series into a single
          #     time series, where the value of each data point in the resulting series is
          #     a function of all the already aligned values in the input time series.
          #
          #     Not all reducer operations can be applied to all time series. The valid
          #     choices depend on the `metric_kind` and the `value_type` of the original
          #     time series. Reduction can yield a time series with a different
          #     `metric_kind` or `value_type` than the input time series.
          #
          #     Time series data must first be aligned (see `per_series_aligner`) in order
          #     to perform cross-time series reduction. If `cross_series_reducer` is
          #     specified, then `per_series_aligner` must be specified, and must not be
          #     `ALIGN_NONE`. An `alignment_period` must also be specified; otherwise, an
          #     error is returned.
          # @!attribute [rw] group_by_fields
          #   @return [::Array<::String>]
          #     The set of fields to preserve when `cross_series_reducer` is
          #     specified. The `group_by_fields` determine how the time series are
          #     partitioned into subsets prior to applying the aggregation
          #     operation. Each subset contains time series that have the same
          #     value for each of the grouping fields. Each individual time
          #     series is a member of exactly one subset. The
          #     `cross_series_reducer` is applied to each subset of time series.
          #     It is not possible to reduce across different resource types, so
          #     this field implicitly contains `resource.type`.  Fields not
          #     specified in `group_by_fields` are aggregated away.  If
          #     `group_by_fields` is not specified and all the time series have
          #     the same resource type, then the time series are aggregated into
          #     a single output time series. If `cross_series_reducer` is not
          #     defined, this field is ignored.
          class Aggregation
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods

            # The `Aligner` specifies the operation that will be applied to the data
            # points in each alignment period in a time series. Except for
            # `ALIGN_NONE`, which specifies that no operation be applied, each alignment
            # operation replaces the set of data values in each alignment period with
            # a single value: the result of applying the operation to the data values.
            # An aligned time series has a single data value at the end of each
            # `alignment_period`.
            #
            # An alignment operation can change the data type of the values, too. For
            # example, if you apply a counting operation to boolean values, the data
            # `value_type` in the original time series is `BOOLEAN`, but the `value_type`
            # in the aligned result is `INT64`.
            module Aligner
              # No alignment. Raw data is returned. Not valid if cross-series reduction
              # is requested. The `value_type` of the result is the same as the
              # `value_type` of the input.
              ALIGN_NONE = 0

              # Align and convert to
              # [DELTA][google.api.MetricDescriptor.MetricKind.DELTA].
              # The output is `delta = y1 - y0`.
              #
              # This alignment is valid for
              # [CUMULATIVE][google.api.MetricDescriptor.MetricKind.CUMULATIVE] and
              # `DELTA` metrics. If the selected alignment period results in periods
              # with no data, then the aligned value for such a period is created by
              # interpolation. The `value_type`  of the aligned result is the same as
              # the `value_type` of the input.
              ALIGN_DELTA = 1

              # Align and convert to a rate. The result is computed as
              # `rate = (y1 - y0)/(t1 - t0)`, or "delta over time".
              # Think of this aligner as providing the slope of the line that passes
              # through the value at the start and at the end of the `alignment_period`.
              #
              # This aligner is valid for `CUMULATIVE`
              # and `DELTA` metrics with numeric values. If the selected alignment
              # period results in periods with no data, then the aligned value for
              # such a period is created by interpolation. The output is a `GAUGE`
              # metric with `value_type` `DOUBLE`.
              #
              # If, by "rate", you mean "percentage change", see the
              # `ALIGN_PERCENT_CHANGE` aligner instead.
              ALIGN_RATE = 2

              # Align by interpolating between adjacent points around the alignment
              # period boundary. This aligner is valid for `GAUGE` metrics with
              # numeric values. The `value_type` of the aligned result is the same as the
              # `value_type` of the input.
              ALIGN_INTERPOLATE = 3

              # Align by moving the most recent data point before the end of the
              # alignment period to the boundary at the end of the alignment
              # period. This aligner is valid for `GAUGE` metrics. The `value_type` of
              # the aligned result is the same as the `value_type` of the input.
              ALIGN_NEXT_OLDER = 4

              # Align the time series by returning the minimum value in each alignment
              # period. This aligner is valid for `GAUGE` and `DELTA` metrics with
              # numeric values. The `value_type` of the aligned result is the same as
              # the `value_type` of the input.
              ALIGN_MIN = 10

              # Align the time series by returning the maximum value in each alignment
              # period. This aligner is valid for `GAUGE` and `DELTA` metrics with
              # numeric values. The `value_type` of the aligned result is the same as
              # the `value_type` of the input.
              ALIGN_MAX = 11

              # Align the time series by returning the mean value in each alignment
              # period. This aligner is valid for `GAUGE` and `DELTA` metrics with
              # numeric values. The `value_type` of the aligned result is `DOUBLE`.
              ALIGN_MEAN = 12

              # Align the time series by returning the number of values in each alignment
              # period. This aligner is valid for `GAUGE` and `DELTA` metrics with
              # numeric or Boolean values. The `value_type` of the aligned result is
              # `INT64`.
              ALIGN_COUNT = 13

              # Align the time series by returning the sum of the values in each
              # alignment period. This aligner is valid for `GAUGE` and `DELTA`
              # metrics with numeric and distribution values. The `value_type` of the
              # aligned result is the same as the `value_type` of the input.
              ALIGN_SUM = 14

              # Align the time series by returning the standard deviation of the values
              # in each alignment period. This aligner is valid for `GAUGE` and
              # `DELTA` metrics with numeric values. The `value_type` of the output is
              # `DOUBLE`.
              ALIGN_STDDEV = 15

              # Align the time series by returning the number of `True` values in
              # each alignment period. This aligner is valid for `GAUGE` metrics with
              # Boolean values. The `value_type` of the output is `INT64`.
              ALIGN_COUNT_TRUE = 16

              # Align the time series by returning the number of `False` values in
              # each alignment period. This aligner is valid for `GAUGE` metrics with
              # Boolean values. The `value_type` of the output is `INT64`.
              ALIGN_COUNT_FALSE = 24

              # Align the time series by returning the ratio of the number of `True`
              # values to the total number of values in each alignment period. This
              # aligner is valid for `GAUGE` metrics with Boolean values. The output
              # value is in the range [0.0, 1.0] and has `value_type` `DOUBLE`.
              ALIGN_FRACTION_TRUE = 17

              # Align the time series by using [percentile
              # aggregation](https://en.wikipedia.org/wiki/Percentile). The resulting
              # data point in each alignment period is the 99th percentile of all data
              # points in the period. This aligner is valid for `GAUGE` and `DELTA`
              # metrics with distribution values. The output is a `GAUGE` metric with
              # `value_type` `DOUBLE`.
              ALIGN_PERCENTILE_99 = 18

              # Align the time series by using [percentile
              # aggregation](https://en.wikipedia.org/wiki/Percentile). The resulting
              # data point in each alignment period is the 95th percentile of all data
              # points in the period. This aligner is valid for `GAUGE` and `DELTA`
              # metrics with distribution values. The output is a `GAUGE` metric with
              # `value_type` `DOUBLE`.
              ALIGN_PERCENTILE_95 = 19

              # Align the time series by using [percentile
              # aggregation](https://en.wikipedia.org/wiki/Percentile). The resulting
              # data point in each alignment period is the 50th percentile of all data
              # points in the period. This aligner is valid for `GAUGE` and `DELTA`
              # metrics with distribution values. The output is a `GAUGE` metric with
              # `value_type` `DOUBLE`.
              ALIGN_PERCENTILE_50 = 20

              # Align the time series by using [percentile
              # aggregation](https://en.wikipedia.org/wiki/Percentile). The resulting
              # data point in each alignment period is the 5th percentile of all data
              # points in the period. This aligner is valid for `GAUGE` and `DELTA`
              # metrics with distribution values. The output is a `GAUGE` metric with
              # `value_type` `DOUBLE`.
              ALIGN_PERCENTILE_05 = 21

              # Align and convert to a percentage change. This aligner is valid for
              # `GAUGE` and `DELTA` metrics with numeric values. This alignment returns
              # `((current - previous)/previous) * 100`, where the value of `previous` is
              # determined based on the `alignment_period`.
              #
              # If the values of `current` and `previous` are both 0, then the returned
              # value is 0. If only `previous` is 0, the returned value is infinity.
              #
              # A 10-minute moving mean is computed at each point of the alignment period
              # prior to the above calculation to smooth the metric and prevent false
              # positives from very short-lived spikes. The moving mean is only
              # applicable for data whose values are `>= 0`. Any values `< 0` are
              # treated as a missing datapoint, and are ignored. While `DELTA`
              # metrics are accepted by this alignment, special care should be taken that
              # the values for the metric will always be positive. The output is a
              # `GAUGE` metric with `value_type` `DOUBLE`.
              ALIGN_PERCENT_CHANGE = 23
            end

            # A Reducer operation describes how to aggregate data points from multiple
            # time series into a single time series, where the value of each data point
            # in the resulting series is a function of all the already aligned values in
            # the input time series.
            module Reducer
              # No cross-time series reduction. The output of the `Aligner` is
              # returned.
              REDUCE_NONE = 0

              # Reduce by computing the mean value across time series for each
              # alignment period. This reducer is valid for
              # [DELTA][google.api.MetricDescriptor.MetricKind.DELTA] and
              # [GAUGE][google.api.MetricDescriptor.MetricKind.GAUGE] metrics with
              # numeric or distribution values. The `value_type` of the output is
              # [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
              REDUCE_MEAN = 1

              # Reduce by computing the minimum value across time series for each
              # alignment period. This reducer is valid for `DELTA` and `GAUGE` metrics
              # with numeric values. The `value_type` of the output is the same as the
              # `value_type` of the input.
              REDUCE_MIN = 2

              # Reduce by computing the maximum value across time series for each
              # alignment period. This reducer is valid for `DELTA` and `GAUGE` metrics
              # with numeric values. The `value_type` of the output is the same as the
              # `value_type` of the input.
              REDUCE_MAX = 3

              # Reduce by computing the sum across time series for each
              # alignment period. This reducer is valid for `DELTA` and `GAUGE` metrics
              # with numeric and distribution values. The `value_type` of the output is
              # the same as the `value_type` of the input.
              REDUCE_SUM = 4

              # Reduce by computing the standard deviation across time series
              # for each alignment period. This reducer is valid for `DELTA` and
              # `GAUGE` metrics with numeric or distribution values. The `value_type`
              # of the output is `DOUBLE`.
              REDUCE_STDDEV = 5

              # Reduce by computing the number of data points across time series
              # for each alignment period. This reducer is valid for `DELTA` and
              # `GAUGE` metrics of numeric, Boolean, distribution, and string
              # `value_type`. The `value_type` of the output is `INT64`.
              REDUCE_COUNT = 6

              # Reduce by computing the number of `True`-valued data points across time
              # series for each alignment period. This reducer is valid for `DELTA` and
              # `GAUGE` metrics of Boolean `value_type`. The `value_type` of the output
              # is `INT64`.
              REDUCE_COUNT_TRUE = 7

              # Reduce by computing the number of `False`-valued data points across time
              # series for each alignment period. This reducer is valid for `DELTA` and
              # `GAUGE` metrics of Boolean `value_type`. The `value_type` of the output
              # is `INT64`.
              REDUCE_COUNT_FALSE = 15

              # Reduce by computing the ratio of the number of `True`-valued data points
              # to the total number of data points for each alignment period. This
              # reducer is valid for `DELTA` and `GAUGE` metrics of Boolean `value_type`.
              # The output value is in the range [0.0, 1.0] and has `value_type`
              # `DOUBLE`.
              REDUCE_FRACTION_TRUE = 8

              # Reduce by computing the [99th
              # percentile](https://en.wikipedia.org/wiki/Percentile) of data points
              # across time series for each alignment period. This reducer is valid for
              # `GAUGE` and `DELTA` metrics of numeric and distribution type. The value
              # of the output is `DOUBLE`.
              REDUCE_PERCENTILE_99 = 9

              # Reduce by computing the [95th
              # percentile](https://en.wikipedia.org/wiki/Percentile) of data points
              # across time series for each alignment period. This reducer is valid for
              # `GAUGE` and `DELTA` metrics of numeric and distribution type. The value
              # of the output is `DOUBLE`.
              REDUCE_PERCENTILE_95 = 10

              # Reduce by computing the [50th
              # percentile](https://en.wikipedia.org/wiki/Percentile) of data points
              # across time series for each alignment period. This reducer is valid for
              # `GAUGE` and `DELTA` metrics of numeric and distribution type. The value
              # of the output is `DOUBLE`.
              REDUCE_PERCENTILE_50 = 11

              # Reduce by computing the [5th
              # percentile](https://en.wikipedia.org/wiki/Percentile) of data points
              # across time series for each alignment period. This reducer is valid for
              # `GAUGE` and `DELTA` metrics of numeric and distribution type. The value
              # of the output is `DOUBLE`.
              REDUCE_PERCENTILE_05 = 12
            end
          end

          # Describes a ranking-based time series filter. Each input time series is
          # ranked with an aligner. The filter will allow up to `num_time_series` time
          # series to pass through it, selecting them based on the relative ranking.
          #
          # For example, if `ranking_method` is `METHOD_MEAN`,`direction` is `BOTTOM`,
          # and `num_time_series` is 3, then the 3 times series with the lowest mean
          # values will pass through the filter.
          # @!attribute [rw] ranking_method
          #   @return [::Google::Cloud::Monitoring::Dashboard::V1::PickTimeSeriesFilter::Method]
          #     `ranking_method` is applied to each time series independently to produce
          #     the value which will be used to compare the time series to other time
          #     series.
          # @!attribute [rw] num_time_series
          #   @return [::Integer]
          #     How many time series to allow to pass through the filter.
          # @!attribute [rw] direction
          #   @return [::Google::Cloud::Monitoring::Dashboard::V1::PickTimeSeriesFilter::Direction]
          #     How to use the ranking to select time series that pass through the filter.
          class PickTimeSeriesFilter
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods

            # The value reducers that can be applied to a `PickTimeSeriesFilter`.
            module Method
              # Not allowed. You must specify a different `Method` if you specify a
              # `PickTimeSeriesFilter`.
              METHOD_UNSPECIFIED = 0

              # Select the mean of all values.
              METHOD_MEAN = 1

              # Select the maximum value.
              METHOD_MAX = 2

              # Select the minimum value.
              METHOD_MIN = 3

              # Compute the sum of all values.
              METHOD_SUM = 4

              # Select the most recent value.
              METHOD_LATEST = 5
            end

            # Describes the ranking directions.
            module Direction
              # Not allowed. You must specify a different `Direction` if you specify a
              # `PickTimeSeriesFilter`.
              DIRECTION_UNSPECIFIED = 0

              # Pass the highest `num_time_series` ranking inputs.
              TOP = 1

              # Pass the lowest `num_time_series` ranking inputs.
              BOTTOM = 2
            end
          end

          # A filter that ranks streams based on their statistical relation to other
          # streams in a request.
          # Note: This field is deprecated and completely ignored by the API.
          # @!attribute [rw] ranking_method
          #   @return [::Google::Cloud::Monitoring::Dashboard::V1::StatisticalTimeSeriesFilter::Method]
          #     `rankingMethod` is applied to a set of time series, and then the produced
          #     value for each individual time series is used to compare a given time
          #     series to others.
          #     These are methods that cannot be applied stream-by-stream, but rather
          #     require the full context of a request to evaluate time series.
          # @!attribute [rw] num_time_series
          #   @return [::Integer]
          #     How many time series to output.
          class StatisticalTimeSeriesFilter
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods

            # The filter methods that can be applied to a stream.
            module Method
              # Not allowed in well-formed requests.
              METHOD_UNSPECIFIED = 0

              # Compute the outlier score of each stream.
              METHOD_CLUSTER_OUTLIER = 1
            end
          end
        end
      end
    end
  end
end