google-cloud-monitoring 0.21.0 → 0.22.0

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

@@ -0,0 +1,69 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# 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
+#
+# http://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 V3
+      # The description of a dynamic collection of monitored resources. Each group
+      # has a filter that is matched against monitored resources and their associated
+      # metadata. If a group's filter matches an available monitored resource, then
+      # that resource is a member of that group.  Groups can contain any number of
+      # monitored resources, and each monitored resource can be a member of any
+      # number of groups.
+      #
+      # Groups can be nested in parent-child hierarchies. The +parentName+ field
+      # identifies an optional parent for each group.  If a group has a parent, then
+      # the only monitored resources available to be matched by the group's filter
+      # are the resources contained in the parent group.  In other words, a group
+      # contains the monitored resources that match its filter and the filters of all
+      # the group's ancestors.  A group without a parent can contain any monitored
+      # resource.
+      #
+      # For example, consider an infrastructure running a set of instances with two
+      # user-defined tags: +"environment"+ and +"role"+. A parent group has a filter,
+      # +environment="production"+.  A child of that parent group has a filter,
+      # +role="transcoder"+.  The parent group contains all instances in the
+      # production environment, regardless of their roles.  The child group contains
+      # instances that have the transcoder role *and* are in the production
+      # environment.
+      #
+      # The monitored resources contained in a group can change at any moment,
+      # depending on what resources exist and what filters are associated with the
+      # group and its ancestors.
+      # @!attribute [rw] name
+      #   @return [String]
+      #     Output only. The name of this group. The format is
+      #     +"projects/{project_id_or_number}/groups/{group_id}"+.
+      #     When creating a group, this field is ignored and a new name is created
+      #     consisting of the project specified in the call to +CreateGroup+
+      #     and a unique +{group_id}+ that is generated automatically.
+      # @!attribute [rw] display_name
+      #   @return [String]
+      #     A user-assigned name for this group, used only for display purposes.
+      # @!attribute [rw] parent_name
+      #   @return [String]
+      #     The name of the group's parent, if it has one.
+      #     The format is +"projects/{project_id_or_number}/groups/{group_id}"+.
+      #     For groups with no parent, +parentName+ is the empty string, +""+.
+      # @!attribute [rw] filter
+      #   @return [String]
+      #     The filter used to determine which monitored resources belong to this group.
+      # @!attribute [rw] is_cluster
+      #   @return [true, false]
+      #     If true, the members of this group are considered to be a cluster.
+      #     The system can perform additional analysis on groups that are clusters.
+      class Group; end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# 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
+#
+# http://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 V3
+      # A single data point in a time series.
+      # @!attribute [rw] interval
+      #   @return [Google::Monitoring::V3::TimeInterval]
+      #     The time interval to which the data point applies.  For GAUGE metrics, only
+      #     the end time of the interval is used.  For DELTA metrics, the start and end
+      #     time should specify a non-zero interval, with subsequent points specifying
+      #     contiguous and non-overlapping intervals.  For CUMULATIVE metrics, the
+      #     start and end time should specify a non-zero interval, with subsequent
+      #     points specifying the same start time and increasing end times, until an
+      #     event resets the cumulative value to zero and sets a new start time for the
+      #     following points.
+      # @!attribute [rw] value
+      #   @return [Google::Monitoring::V3::TypedValue]
+      #     The value of the data point.
+      class Point; end
+
+      # A collection of data points that describes the time-varying values
+      # of a metric. A time series is identified by a combination of a
+      # fully-specified monitored resource and a fully-specified metric.
+      # This type is used for both listing and creating time series.
+      # @!attribute [rw] metric
+      #   @return [Google::Api::Metric]
+      #     The associated metric. A fully-specified metric used to identify the time
+      #     series.
+      # @!attribute [rw] resource
+      #   @return [Google::Api::MonitoredResource]
+      #     The associated resource. A fully-specified monitored resource used to
+      #     identify the time series.
+      # @!attribute [rw] metric_kind
+      #   @return [Google::Api::MetricDescriptor::MetricKind]
+      #     The metric kind of the time series. When listing time series, this metric
+      #     kind might be different from the metric kind of the associated metric if
+      #     this time series is an alignment or reduction of other time series.
+      #
+      #     When creating a time series, this field is optional. If present, it must be
+      #     the same as the metric kind of the associated metric. If the associated
+      #     metric's descriptor must be auto-created, then this field specifies the
+      #     metric kind of the new descriptor and must be either +GAUGE+ (the default)
+      #     or +CUMULATIVE+.
+      # @!attribute [rw] value_type
+      #   @return [Google::Api::MetricDescriptor::ValueType]
+      #     The value type of the time series. When listing time series, this value
+      #     type might be different from the value type of the associated metric if
+      #     this time series is an alignment or reduction of other time series.
+      #
+      #     When creating a time series, this field is optional. If present, it must be
+      #     the same as the type of the data in the +points+ field.
+      # @!attribute [rw] points
+      #   @return [Array<Google::Monitoring::V3::Point>]
+      #     The data points of this time series. When listing time series, the order of
+      #     the points is specified by the list method.
+      #
+      #     When creating a time series, this field must contain exactly one point and
+      #     the point's type must be the same as the value type of the associated
+      #     metric. If the associated metric's descriptor must be auto-created, then
+      #     the value type of the descriptor is determined by the point's type, which
+      #     must be +BOOL+, +INT64+, +DOUBLE+, or +DISTRIBUTION+.
+      class TimeSeries; end
+    end
+  end
+end

data/lib/google/cloud/monitoring/v3/doc/google/protobuf/duration.rb

@@ -0,0 +1,71 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# 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
+#
+# http://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.
+    #
+    # 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;
+    #     }
+    # @!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.
+    # @!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/v3/doc/google/protobuf/timestamp.rb

@@ -0,0 +1,83 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# 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
+#
+# http://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 Timestamp represents a point in time independent of any time zone
+    # or calendar, represented as seconds and fractions of seconds at
+    # nanosecond resolution in UTC Epoch time. It is encoded using the
+    # Proleptic Gregorian Calendar which extends the Gregorian calendar
+    # backwards to year one. It is encoded assuming all minutes are 60
+    # seconds long, i.e. leap seconds are "smeared" so that no leap second
+    # table is needed for interpretation. Range is from
+    # 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+    # By restricting to that range, we ensure that we can convert to
+    # and from  RFC 3339 date strings.
+    # See {https://www.ietf.org/rfc/rfc3339.txt}[https://www.ietf.org/rfc/rfc3339.txt].
+    #
+    # Example 1: Compute Timestamp from POSIX +time()+.
+    #
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds(time(NULL));
+    #     timestamp.set_nanos(0);
+    #
+    # Example 2: Compute Timestamp from POSIX +gettimeofday()+.
+    #
+    #     struct timeval tv;
+    #     gettimeofday(&tv, NULL);
+    #
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds(tv.tv_sec);
+    #     timestamp.set_nanos(tv.tv_usec * 1000);
+    #
+    # Example 3: Compute Timestamp from Win32 +GetSystemTimeAsFileTime()+.
+    #
+    #     FILETIME ft;
+    #     GetSystemTimeAsFileTime(&ft);
+    #     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+    #
+    #     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+    #     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+    #     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+    #
+    # Example 4: Compute Timestamp from Java +System.currentTimeMillis()+.
+    #
+    #     long millis = System.currentTimeMillis();
+    #
+    #     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+    #         .setNanos((int) ((millis % 1000) * 1000000)).build();
+    #
+    #
+    # Example 5: Compute Timestamp from current time in Python.
+    #
+    #     now = time.time()
+    #     seconds = int(now)
+    #     nanos = int((now - seconds) * 10**9)
+    #     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+    # @!attribute [rw] seconds
+    #   @return [Integer]
+    #     Represents seconds of UTC time since Unix epoch
+    #     1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+    #     9999-12-31T23:59:59Z inclusive.
+    # @!attribute [rw] nanos
+    #   @return [Integer]
+    #     Non-negative fractions of a second at nanosecond resolution. Negative
+    #     second values with fractions must still have non-negative nanos values
+    #     that count forward in time. Must be from 0 to 999,999,999
+    #     inclusive.
+    class Timestamp; end
+  end
+end

data/lib/google/cloud/monitoring/v3/{group_service_api.rb → group_service_client.rb}

@@ -47,7 +47,7 @@ module Google
         #
         # @!attribute [r] group_service_stub
         #   @return [Google::Monitoring::V3::GroupService::Stub]
-        class GroupServiceApi
+        class GroupServiceClient
           attr_reader :group_service_stub
 
           # The default address of the service.
@@ -76,6 +76,10 @@ module Google
           # The scopes needed to make gRPC calls to all of the methods defined in
           # this service.
           ALL_SCOPES = [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/monitoring",
+            "https://www.googleapis.com/auth/monitoring.read",
+            "https://www.googleapis.com/auth/monitoring.write"
           ].freeze
 
           PROJECT_PATH_TEMPLATE = Google::Gax::PathTemplate.new(
@@ -166,6 +170,7 @@ module Google
             require "google/gax/grpc"
             require "google/monitoring/v3/group_service_services_pb"
 
+
             google_api_client = "#{app_name}/#{app_version} " \
               "#{CODE_GEN_NAME_VERSION} gax/#{Google::Gax::VERSION} " \
               "ruby/#{RUBY_VERSION}".freeze
@@ -258,20 +263,20 @@ module Google
           #   object.
           # @raise [Google::Gax::GaxError] if the RPC is aborted.
           # @example
-          #   require "google/cloud/monitoring/v3/group_service_api"
+          #   require "google/cloud/monitoring/v3/group_service_client"
           #
-          #   GroupServiceApi = Google::Cloud::Monitoring::V3::GroupServiceApi
+          #   GroupServiceClient = Google::Cloud::Monitoring::V3::GroupServiceClient
           #
-          #   group_service_api = GroupServiceApi.new
-          #   formatted_name = GroupServiceApi.project_path("[PROJECT]")
+          #   group_service_client = GroupServiceClient.new
+          #   formatted_name = GroupServiceClient.project_path("[PROJECT]")
           #
           #   # Iterate over all results.
-          #   group_service_api.list_groups(formatted_name).each do |element|
+          #   group_service_client.list_groups(formatted_name).each do |element|
           #     # Process element.
           #   end
           #
           #   # Or iterate over results one page at a time.
-          #   group_service_api.list_groups(formatted_name).each_page do |page|
+          #   group_service_client.list_groups(formatted_name).each_page do |page|
           #     # Process each page at a time.
           #     page.each do |element|
           #       # Process element.
@@ -285,13 +290,13 @@ module Google
               descendants_of_group: nil,
               page_size: nil,
               options: nil
-            req = Google::Monitoring::V3::ListGroupsRequest.new(
-              name: name
-            )
-            req.children_of_group = children_of_group unless children_of_group.nil?
-            req.ancestors_of_group = ancestors_of_group unless ancestors_of_group.nil?
-            req.descendants_of_group = descendants_of_group unless descendants_of_group.nil?
-            req.page_size = page_size unless page_size.nil?
+            req = Google::Monitoring::V3::ListGroupsRequest.new({
+              name: name,
+              children_of_group: children_of_group,
+              ancestors_of_group: ancestors_of_group,
+              descendants_of_group: descendants_of_group,
+              page_size: page_size
+            }.delete_if { |_, v| v.nil? })
             @list_groups.call(req, options)
           end
 
@@ -306,20 +311,20 @@ module Google
           # @return [Google::Monitoring::V3::Group]
           # @raise [Google::Gax::GaxError] if the RPC is aborted.
           # @example
-          #   require "google/cloud/monitoring/v3/group_service_api"
+          #   require "google/cloud/monitoring/v3/group_service_client"
           #
-          #   GroupServiceApi = Google::Cloud::Monitoring::V3::GroupServiceApi
+          #   GroupServiceClient = Google::Cloud::Monitoring::V3::GroupServiceClient
           #
-          #   group_service_api = GroupServiceApi.new
-          #   formatted_name = GroupServiceApi.group_path("[PROJECT]", "[GROUP]")
-          #   response = group_service_api.get_group(formatted_name)
+          #   group_service_client = GroupServiceClient.new
+          #   formatted_name = GroupServiceClient.group_path("[PROJECT]", "[GROUP]")
+          #   response = group_service_client.get_group(formatted_name)
 
           def get_group \
               name,
               options: nil
-            req = Google::Monitoring::V3::GetGroupRequest.new(
+            req = Google::Monitoring::V3::GetGroupRequest.new({
               name: name
-            )
+            }.delete_if { |_, v| v.nil? })
             @get_group.call(req, options)
           end
 
@@ -339,26 +344,26 @@ module Google
           # @return [Google::Monitoring::V3::Group]
           # @raise [Google::Gax::GaxError] if the RPC is aborted.
           # @example
-          #   require "google/cloud/monitoring/v3/group_service_api"
+          #   require "google/cloud/monitoring/v3/group_service_client"
           #
           #   Group = Google::Monitoring::V3::Group
-          #   GroupServiceApi = Google::Cloud::Monitoring::V3::GroupServiceApi
+          #   GroupServiceClient = Google::Cloud::Monitoring::V3::GroupServiceClient
           #
-          #   group_service_api = GroupServiceApi.new
-          #   formatted_name = GroupServiceApi.project_path("[PROJECT]")
+          #   group_service_client = GroupServiceClient.new
+          #   formatted_name = GroupServiceClient.project_path("[PROJECT]")
           #   group = Group.new
-          #   response = group_service_api.create_group(formatted_name, group)
+          #   response = group_service_client.create_group(formatted_name, group)
 
           def create_group \
               name,
               group,
               validate_only: nil,
               options: nil
-            req = Google::Monitoring::V3::CreateGroupRequest.new(
+            req = Google::Monitoring::V3::CreateGroupRequest.new({
               name: name,
-              group: group
-            )
-            req.validate_only = validate_only unless validate_only.nil?
+              group: group,
+              validate_only: validate_only
+            }.delete_if { |_, v| v.nil? })
             @create_group.call(req, options)
           end
 
@@ -376,23 +381,23 @@ module Google
           # @return [Google::Monitoring::V3::Group]
           # @raise [Google::Gax::GaxError] if the RPC is aborted.
           # @example
-          #   require "google/cloud/monitoring/v3/group_service_api"
+          #   require "google/cloud/monitoring/v3/group_service_client"
           #
           #   Group = Google::Monitoring::V3::Group
-          #   GroupServiceApi = Google::Cloud::Monitoring::V3::GroupServiceApi
+          #   GroupServiceClient = Google::Cloud::Monitoring::V3::GroupServiceClient
           #
-          #   group_service_api = GroupServiceApi.new
+          #   group_service_client = GroupServiceClient.new
           #   group = Group.new
-          #   response = group_service_api.update_group(group)
+          #   response = group_service_client.update_group(group)
 
           def update_group \
               group,
               validate_only: nil,
               options: nil
-            req = Google::Monitoring::V3::UpdateGroupRequest.new(
-              group: group
-            )
-            req.validate_only = validate_only unless validate_only.nil?
+            req = Google::Monitoring::V3::UpdateGroupRequest.new({
+              group: group,
+              validate_only: validate_only
+            }.delete_if { |_, v| v.nil? })
             @update_group.call(req, options)
           end
 
@@ -406,21 +411,22 @@ module Google
           #   retries, etc.
           # @raise [Google::Gax::GaxError] if the RPC is aborted.
           # @example
-          #   require "google/cloud/monitoring/v3/group_service_api"
+          #   require "google/cloud/monitoring/v3/group_service_client"
           #
-          #   GroupServiceApi = Google::Cloud::Monitoring::V3::GroupServiceApi
+          #   GroupServiceClient = Google::Cloud::Monitoring::V3::GroupServiceClient
           #
-          #   group_service_api = GroupServiceApi.new
-          #   formatted_name = GroupServiceApi.group_path("[PROJECT]", "[GROUP]")
-          #   group_service_api.delete_group(formatted_name)
+          #   group_service_client = GroupServiceClient.new
+          #   formatted_name = GroupServiceClient.group_path("[PROJECT]", "[GROUP]")
+          #   group_service_client.delete_group(formatted_name)
 
           def delete_group \
               name,
               options: nil
-            req = Google::Monitoring::V3::DeleteGroupRequest.new(
+            req = Google::Monitoring::V3::DeleteGroupRequest.new({
               name: name
-            )
+            }.delete_if { |_, v| v.nil? })
             @delete_group.call(req, options)
+            nil
           end
 
           # Lists the monitored resources that are members of a group.
@@ -457,20 +463,20 @@ module Google
           #   object.
           # @raise [Google::Gax::GaxError] if the RPC is aborted.
           # @example
-          #   require "google/cloud/monitoring/v3/group_service_api"
+          #   require "google/cloud/monitoring/v3/group_service_client"
           #
-          #   GroupServiceApi = Google::Cloud::Monitoring::V3::GroupServiceApi
+          #   GroupServiceClient = Google::Cloud::Monitoring::V3::GroupServiceClient
           #
-          #   group_service_api = GroupServiceApi.new
-          #   formatted_name = GroupServiceApi.group_path("[PROJECT]", "[GROUP]")
+          #   group_service_client = GroupServiceClient.new
+          #   formatted_name = GroupServiceClient.group_path("[PROJECT]", "[GROUP]")
           #
           #   # Iterate over all results.
-          #   group_service_api.list_group_members(formatted_name).each do |element|
+          #   group_service_client.list_group_members(formatted_name).each do |element|
           #     # Process element.
           #   end
           #
           #   # Or iterate over results one page at a time.
-          #   group_service_api.list_group_members(formatted_name).each_page do |page|
+          #   group_service_client.list_group_members(formatted_name).each_page do |page|
           #     # Process each page at a time.
           #     page.each do |element|
           #       # Process element.
@@ -483,12 +489,12 @@ module Google
               filter: nil,
               interval: nil,
               options: nil
-            req = Google::Monitoring::V3::ListGroupMembersRequest.new(
-              name: name
-            )
-            req.page_size = page_size unless page_size.nil?
-            req.filter = filter unless filter.nil?
-            req.interval = interval unless interval.nil?
+            req = Google::Monitoring::V3::ListGroupMembersRequest.new({
+              name: name,
+              page_size: page_size,
+              filter: filter,
+              interval: interval
+            }.delete_if { |_, v| v.nil? })
             @list_group_members.call(req, options)
           end
         end