google-cloud-monitoring 0.33.1 → 0.34.0

data/lib/google/cloud/monitoring/dashboard/v1/doc/google/monitoring/dashboard/v1/widget.rb

@@ -0,0 +1,41 @@
+# Copyright 2019 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.
+
+
+module Google
+  module Monitoring
+    module Dashboard
+      module V1
+        # Widget contains a single dashboard component and configuration of how to
+        # present the component in the dashboard.
+        # @!attribute [rw] title
+        #   @return [String]
+        #     Optional. The title of the widget.
+        # @!attribute [rw] xy_chart
+        #   @return [Google::Monitoring::Dashboard::V1::XyChart]
+        #     A chart of time series data.
+        # @!attribute [rw] scorecard
+        #   @return [Google::Monitoring::Dashboard::V1::Scorecard]
+        #     A scorecard summarizing time series data.
+        # @!attribute [rw] text
+        #   @return [Google::Monitoring::Dashboard::V1::Text]
+        #     A raw string or markdown displaying textual content.
+        # @!attribute [rw] blank
+        #   @return [Google::Protobuf::Empty]
+        #     A blank space.
+        class Widget; end
+      end
+    end
+  end
+end

data/lib/google/cloud/monitoring/dashboard/v1/doc/google/monitoring/dashboard/v1/xychart.rb

@@ -0,0 +1,141 @@
+# Copyright 2019 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.
+
+
+module Google
+  module Monitoring
+    module Dashboard
+      module V1
+        # A chart that displays data on a 2D (X and Y axes) plane.
+        # @!attribute [rw] data_sets
+        #   @return [Array<Google::Monitoring::Dashboard::V1::XyChart::DataSet>]
+        #     The data displayed in this chart.
+        # @!attribute [rw] timeshift_duration
+        #   @return [Google::Protobuf::Duration]
+        #     The duration used to display a comparison chart. A comparison chart
+        #     simultaneously shows values from two similar-length time periods
+        #     (e.g., week-over-week metrics).
+        #     The duration must be positive, and it can only be applied to charts with
+        #     data sets of LINE plot type.
+        # @!attribute [rw] thresholds
+        #   @return [Array<Google::Monitoring::Dashboard::V1::Threshold>]
+        #     Threshold lines drawn horizontally across the chart.
+        # @!attribute [rw] x_axis
+        #   @return [Google::Monitoring::Dashboard::V1::XyChart::Axis]
+        #     The properties applied to the X axis.
+        # @!attribute [rw] y_axis
+        #   @return [Google::Monitoring::Dashboard::V1::XyChart::Axis]
+        #     The properties applied to the Y axis.
+        # @!attribute [rw] chart_options
+        #   @return [Google::Monitoring::Dashboard::V1::ChartOptions]
+        #     Display options for the chart.
+        class XyChart
+          # Groups a time series query definition with charting options.
+          # @!attribute [rw] time_series_query
+          #   @return [Google::Monitoring::Dashboard::V1::TimeSeriesQuery]
+          #     Fields for querying time series data from the
+          #     Stackdriver metrics API.
+          # @!attribute [rw] plot_type
+          #   @return [Google::Monitoring::Dashboard::V1::XyChart::DataSet::PlotType]
+          #     How this data should be plotted on the chart.
+          # @!attribute [rw] legend_template
+          #   @return [String]
+          #     A template string for naming `TimeSeries` in the resulting data set.
+          #     This should be a string with interpolations of the form ${label_name},
+          #     which will resolve to the label's value.
+          # @!attribute [rw] min_alignment_period
+          #   @return [Google::Protobuf::Duration]
+          #     Optional. The lower bound on data point frequency for this data set, implemented by
+          #     specifying the minimum alignment period to use in a time series query
+          #     For example, if the data is published once every 10 minutes, the
+          #     `min_alignment_period` should be at least 10 minutes. It would not
+          #     make sense to fetch and align data at one minute intervals.
+          class DataSet
+            # The types of plotting strategies for data sets.
+            module PlotType
+              # Plot type is unspecified. The view will default to `LINE`.
+              PLOT_TYPE_UNSPECIFIED = 0
+
+              # The data is plotted as a set of lines (one line per series).
+              LINE = 1
+
+              # The data is plotted as a set of filled areas (one area per series),
+              # with the areas stacked vertically (the base of each area is the top of
+              # its predecessor, and the base of the first area is the X axis). Since
+              # the areas do not overlap, each is filled with a different opaque color.
+              STACKED_AREA = 2
+
+              # The data is plotted as a set of rectangular boxes (one box per series),
+              # with the boxes stacked vertically (the base of each box is the top of
+              # its predecessor, and the base of the first box is the X axis). Since
+              # the boxes do not overlap, each is filled with a different opaque color.
+              STACKED_BAR = 3
+
+              # The data is plotted as a heatmap. The series being plotted must have a
+              # `DISTRIBUTION` value type. The value of each bucket in the distribution
+              # is displayed as a color. This type is not currently available in the
+              # Stackdriver Monitoring application.
+              HEATMAP = 4
+            end
+          end
+
+          # A chart axis.
+          # @!attribute [rw] label
+          #   @return [String]
+          #     The label of the axis.
+          # @!attribute [rw] scale
+          #   @return [Google::Monitoring::Dashboard::V1::XyChart::Axis::Scale]
+          #     The axis scale. By default, a linear scale is used.
+          class Axis
+            # Types of scales used in axes.
+            module Scale
+              # Scale is unspecified. The view will default to `LINEAR`.
+              SCALE_UNSPECIFIED = 0
+
+              # Linear scale.
+              LINEAR = 1
+
+              # Logarithmic scale (base 10).
+              LOG10 = 2
+            end
+          end
+        end
+
+        # Options to control visual rendering of a chart.
+        # @!attribute [rw] mode
+        #   @return [Google::Monitoring::Dashboard::V1::ChartOptions::Mode]
+        #     The chart mode.
+        class ChartOptions
+          # Chart mode options.
+          module Mode
+            # Mode is unspecified. The view will default to `COLOR`.
+            MODE_UNSPECIFIED = 0
+
+            # The chart distinguishes data series using different color. Line
+            # colors may get reused when there are many lines in the chart.
+            COLOR = 1
+
+            # The chart uses the Stackdriver x-ray mode, in which each
+            # data set is plotted using the same semi-transparent color.
+            X_RAY = 2
+
+            # The chart displays statistics such as average, median, 95th percentile,
+            # and more.
+            STATS = 3
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/monitoring/dashboard/v1/doc/google/protobuf/duration.rb

@@ -0,0 +1,91 @@
+# Copyright 2019 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.
+
+
+module Google
+  module Protobuf
+    # A Duration represents a signed, fixed-length span of time represented
+    # as a count of seconds and fractions of seconds at nanosecond
+    # resolution. It is independent of any calendar and concepts like "day"
+    # or "month". It is related to Timestamp in that the difference between
+    # two Timestamp values is a Duration and it can be added or subtracted
+    # from a Timestamp. Range is approximately +-10,000 years.
+    #
+    # = Examples
+    #
+    # Example 1: Compute Duration from two Timestamps in pseudo code.
+    #
+    #     Timestamp start = ...;
+    #     Timestamp end = ...;
+    #     Duration duration = ...;
+    #
+    #     duration.seconds = end.seconds - start.seconds;
+    #     duration.nanos = end.nanos - start.nanos;
+    #
+    #     if (duration.seconds < 0 && duration.nanos > 0) {
+    #       duration.seconds += 1;
+    #       duration.nanos -= 1000000000;
+    #     } else if (durations.seconds > 0 && duration.nanos < 0) {
+    #       duration.seconds -= 1;
+    #       duration.nanos += 1000000000;
+    #     }
+    #
+    # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+    #
+    #     Timestamp start = ...;
+    #     Duration duration = ...;
+    #     Timestamp end = ...;
+    #
+    #     end.seconds = start.seconds + duration.seconds;
+    #     end.nanos = start.nanos + duration.nanos;
+    #
+    #     if (end.nanos < 0) {
+    #       end.seconds -= 1;
+    #       end.nanos += 1000000000;
+    #     } else if (end.nanos >= 1000000000) {
+    #       end.seconds += 1;
+    #       end.nanos -= 1000000000;
+    #     }
+    #
+    # Example 3: Compute Duration from datetime.timedelta in Python.
+    #
+    #     td = datetime.timedelta(days=3, minutes=10)
+    #     duration = Duration()
+    #     duration.FromTimedelta(td)
+    #
+    # = JSON Mapping
+    #
+    # In JSON format, the Duration type is encoded as a string rather than an
+    # object, where the string ends in the suffix "s" (indicating seconds) and
+    # is preceded by the number of seconds, with nanoseconds expressed as
+    # fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+    # encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+    # be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+    # microsecond should be expressed in JSON format as "3.000001s".
+    # @!attribute [rw] seconds
+    #   @return [Integer]
+    #     Signed seconds of the span of time. Must be from -315,576,000,000
+    #     to +315,576,000,000 inclusive. Note: these bounds are computed from:
+    #     60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+    # @!attribute [rw] nanos
+    #   @return [Integer]
+    #     Signed fractions of a second at nanosecond resolution of the span
+    #     of time. Durations less than one second are represented with a 0
+    #     `seconds` field and a positive or negative `nanos` field. For durations
+    #     of one second or more, a non-zero value for the `nanos` field must be
+    #     of the same sign as the `seconds` field. Must be from -999,999,999
+    #     to +999,999,999 inclusive.
+    class Duration; end
+  end
+end

data/lib/google/cloud/monitoring/dashboard/v1/doc/google/protobuf/empty.rb

@@ -0,0 +1,29 @@
+# Copyright 2019 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.
+
+
+module Google
+  module Protobuf
+    # A generic empty message that you can re-use to avoid defining duplicated
+    # empty messages in your APIs. A typical example is to use it as the request
+    # or the response type of an API method. For instance:
+    #
+    #     service Foo {
+    #       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+    #     }
+    #
+    # The JSON representation for `Empty` is empty JSON object `{}`.
+    class Empty; end
+  end
+end

data/lib/google/cloud/monitoring/v3.rb

@@ -17,6 +17,7 @@ require "google/cloud/monitoring/v3/alert_policy_service_client"
 require "google/cloud/monitoring/v3/group_service_client"
 require "google/cloud/monitoring/v3/metric_service_client"
 require "google/cloud/monitoring/v3/notification_channel_service_client"
+require "google/cloud/monitoring/v3/service_monitoring_service_client"
 require "google/cloud/monitoring/v3/uptime_check_service_client"
 require "google/monitoring/v3/span_context_pb"
 require "google/monitoring/v3/dropped_labels_pb"
@@ -32,7 +33,10 @@ module Google
       # [Stackdriver Monitoring API][Product Documentation]:
       # Manages your Stackdriver Monitoring data and configurations. Most projects
       # must be associated with a Stackdriver account, with a few exceptions as
-      # noted on the individual method pages.
+      # noted on the individual method pages. The table entries below are
+      # presented in alphabetical order, not in order of common use. For
+      # explanations of the concepts found in the table entries, read the
+      # [Stackdriver Monitoring documentation](/monitoring/docs).
       # - [Product Documentation][]
       #
       # ## Quick Start
@@ -385,6 +389,73 @@ module Google
           end
         end
 
+        module ServiceMonitoring
+          ##
+          # The Stackdriver Monitoring Service-Oriented Monitoring API has endpoints for
+          # managing and querying aspects of a workspace's services. These include the
+          # `Service`'s monitored resources, its Service-Level Objectives, and a taxonomy
+          # of categorized Health Metrics.
+          #
+          # @param credentials [Google::Auth::Credentials, String, Hash, GRPC::Core::Channel, GRPC::Core::ChannelCredentials, Proc]
+          #   Provides the means for authenticating requests made by the client. This parameter can
+          #   be many types.
+          #   A `Google::Auth::Credentials` uses a the properties of its represented keyfile for
+          #   authenticating requests made by this client.
+          #   A `String` will be treated as the path to the keyfile to be used for the construction of
+          #   credentials for this client.
+          #   A `Hash` will be treated as the contents of a keyfile to be used for the construction of
+          #   credentials for this client.
+          #   A `GRPC::Core::Channel` will be used to make calls through.
+          #   A `GRPC::Core::ChannelCredentials` for the setting up the RPC client. The channel credentials
+          #   should already be composed with a `GRPC::Core::CallCredentials` object.
+          #   A `Proc` will be used as an updater_proc for the Grpc channel. The proc transforms the
+          #   metadata for requests, generally, to give OAuth credentials.
+          # @param scopes [Array<String>]
+          #   The OAuth scopes for this service. This parameter is ignored if
+          #   an updater_proc is supplied.
+          # @param client_config [Hash]
+          #   A Hash for call options for each method. See
+          #   Google::Gax#construct_settings for the structure of
+          #   this data. Falls back to the default config if not specified
+          #   or the specified config is missing data points.
+          # @param timeout [Numeric]
+          #   The default timeout, in seconds, for calls made through this client.
+          # @param metadata [Hash]
+          #   Default metadata to be sent with each request. This can be overridden on a per call basis.
+          # @param service_address [String]
+          #   Override for the service hostname, or `nil` to leave as the default.
+          # @param service_port [Integer]
+          #   Override for the service port, or `nil` to leave as the default.
+          # @param exception_transformer [Proc]
+          #   An optional proc that intercepts any exceptions raised during an API call to inject
+          #   custom error handling.
+          def self.new \
+              credentials: nil,
+              scopes: nil,
+              client_config: nil,
+              timeout: nil,
+              metadata: nil,
+              service_address: nil,
+              service_port: nil,
+              exception_transformer: nil,
+              lib_name: nil,
+              lib_version: nil
+            kwargs = {
+              credentials: credentials,
+              scopes: scopes,
+              client_config: client_config,
+              timeout: timeout,
+              metadata: metadata,
+              exception_transformer: exception_transformer,
+              lib_name: lib_name,
+              service_address: service_address,
+              service_port: service_port,
+              lib_version: lib_version
+            }.select { |_, v| v != nil }
+            Google::Cloud::Monitoring::V3::ServiceMonitoringServiceClient.new(**kwargs)
+          end
+        end
+
         module UptimeCheck
           ##
           # The UptimeCheckService API is used to manage (list, create, delete, edit)

data/lib/google/cloud/monitoring/v3/alert_policy_service_client_config.json

@@ -21,27 +21,27 @@
       },
       "methods": {
         "ListAlertPolicies": {
-          "timeout_millis": 30000,
+          "timeout_millis": 60000,
           "retry_codes_name": "idempotent",
           "retry_params_name": "default"
         },
         "GetAlertPolicy": {
-          "timeout_millis": 30000,
+          "timeout_millis": 60000,
           "retry_codes_name": "idempotent",
           "retry_params_name": "default"
         },
         "CreateAlertPolicy": {
-          "timeout_millis": 30000,
+          "timeout_millis": 60000,
           "retry_codes_name": "non_idempotent",
           "retry_params_name": "default"
         },
         "DeleteAlertPolicy": {
-          "timeout_millis": 30000,
+          "timeout_millis": 60000,
           "retry_codes_name": "idempotent",
           "retry_params_name": "default"
         },
         "UpdateAlertPolicy": {
-          "timeout_millis": 30000,
+          "timeout_millis": 60000,
           "retry_codes_name": "non_idempotent",
           "retry_params_name": "default"
         }

data/lib/google/cloud/monitoring/v3/doc/google/api/metric.rb

@@ -49,49 +49,22 @@ module Google
     #     Some combinations of `metric_kind` and `value_type` might not be supported.
     # @!attribute [rw] unit
     #   @return [String]
-    #     The unit in which the metric value is reported. It is only applicable
-    #     if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The
-    #     supported units are a subset of [The Unified Code for Units of
-    #     Measure](http://unitsofmeasure.org/ucum.html) standard:
-    #
-    #     **Basic units (UNIT)**
-    #
-    #     * `bit`   bit
-    #     * `By`    byte
-    #     * `s`     second
-    #     * `min`   minute
-    #     * `h`     hour
-    #     * `d`     day
-    #
-    #     **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)
+    #     * `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 (as an infix operator, e.g. `1/s`).
-    #     * `.`    multiplication (as an infix operator, e.g. `GBy.d`)
+    #     * `/`    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:
     #
@@ -106,14 +79,25 @@ module Google
     #
     #     Notes:
     #
-    #     * `Annotation` is just a comment if it follows a `UNIT` and is
-    #       equivalent to `1` if it is used alone. For examples,
-    #       `{requests}/s == 1/s`, `By{transmitted}/s == By/s`.
+    #     * `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 dimensionless value 1, such as in `1/s`.
-    #     * `%` represents dimensionless value 1/100, and annotates values giving
-    #       a percentage.
+    #       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").
     # @!attribute [rw] description
     #   @return [String]
     #     A detailed description of the metric, which can be used in documentation.