Module: Google::Cloud::Monitoring

Defined in:
lib/google/cloud/monitoring.rb,
lib/google/cloud/monitoring/version.rb,
lib/google/cloud/monitoring/dashboard.rb,
lib/google/cloud/monitoring/metrics_scope.rb,
lib/google/cloud/monitoring/dashboard/version.rb,
lib/google/cloud/monitoring/metrics_scope/version.rb

Defined Under Namespace

Modules: Dashboard, MetricsScope

Constant Summary collapse

VERSION = 
"1.11.0"

Class Method Summary collapse

Class Method Details

.alert_policy_service(version: :v3, &block) ⇒ ::Object

Create a new client object for AlertPolicyService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::AlertPolicyService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the AlertPolicyService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the AlertPolicyService service. You can determine whether the method will succeed by calling alert_policy_service_available?.

About AlertPolicyService

The AlertPolicyService API is used to manage (list, create, delete, edit) alert policies in Cloud Monitoring. An alerting policy is a description of the conditions under which some aspect of your system is considered to be "unhealthy" and the ways to notify people or services about this state. In addition to using this API, alert policies can also be managed through Cloud Monitoring, which can be reached by clicking the "Monitoring" tab in Cloud console.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



80
81
82
83
84
85
86
87
88
89
 
# File 'lib/google/cloud/monitoring.rb', line 80

def self.alert_policy_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:AlertPolicyService)
  service_module.const_get(:Client).new(&block)
end

.alert_policy_service_available?(version: :v3) ⇒ boolean

Determines whether the AlertPolicyService service is supported by the current client. If true, you can retrieve a client object by calling alert_policy_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the AlertPolicyService service, or if the versioned client gem needs an update to support the AlertPolicyService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/google/cloud/monitoring.rb', line 102

def self.alert_policy_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :AlertPolicyService
  service_module = service_module.const_get :AlertPolicyService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.configure {|::Google::Cloud.configure.monitoring| ... } ⇒ ::Google::Cloud::Config

Configure the google-cloud-monitoring library.

The following configuration parameters are supported:

  • credentials (type: String, Hash, Google::Auth::Credentials) - The path to the keyfile as a String, the contents of the keyfile as a Hash, or a Google::Auth::Credentials object.
  • lib_name (type: String) - The library name as recorded in instrumentation and logging.
  • lib_version (type: String) - The library version as recorded in instrumentation and logging.
  • interceptors (type: Array<GRPC::ClientInterceptor>) - An array of interceptors that are run before calls are executed.
  • timeout (type: Numeric) - Default timeout in seconds.
  • metadata (type: Hash{Symbol=>String}) - Additional headers to be sent with the call.
  • retry_policy (type: Hash) - The retry policy. The value is a hash with the following keys:
    • :initial_delay (type: Numeric) - The initial delay in seconds.
    • :max_delay (type: Numeric) - The max delay in seconds.
    • :multiplier (type: Numeric) - The incremental backoff multiplier.
    • :jitter (type: Numeric) - The jitter in seconds. Default: 1.0.
    • :retry_codes (type: Array<String>) - The error codes that should trigger a retry.

Yields:

Returns:

  • (::Google::Cloud::Config) —

    The default configuration used by this library



600
601
602
603
604
 
# File 'lib/google/cloud/monitoring.rb', line 600

def self.configure
  yield ::Google::Cloud.configure.monitoring if block_given?

  ::Google::Cloud.configure.monitoring
end

.group_service(version: :v3, &block) ⇒ ::Object

Create a new client object for GroupService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::GroupService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the GroupService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the GroupService service. You can determine whether the method will succeed by calling group_service_available?.

About GroupService

The Group API lets you inspect and manage your groups.

A group is a named filter that is used to identify a collection of monitored resources. Groups are typically used to mirror the physical and/or logical topology of the environment. Because group membership is computed dynamically, monitored resources that are started in the future are automatically placed in matching groups. By using a group to name monitored resources in, for example, an alert policy, the target of that alert policy is updated automatically as monitored resources are added and removed from the infrastructure.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



152
153
154
155
156
157
158
159
160
161
 
# File 'lib/google/cloud/monitoring.rb', line 152

def self.group_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:GroupService)
  service_module.const_get(:Client).new(&block)
end

.group_service_available?(version: :v3) ⇒ boolean

Determines whether the GroupService service is supported by the current client. If true, you can retrieve a client object by calling group_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the GroupService service, or if the versioned client gem needs an update to support the GroupService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/google/cloud/monitoring.rb', line 174

def self.group_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :GroupService
  service_module = service_module.const_get :GroupService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.metric_service(version: :v3, &block) ⇒ ::Object

Create a new client object for MetricService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::MetricService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the MetricService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the MetricService service. You can determine whether the method will succeed by calling metric_service_available?.

About MetricService

Manages metric descriptors, monitored resource descriptors, and time series data.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



214
215
216
217
218
219
220
221
222
223
 
# File 'lib/google/cloud/monitoring.rb', line 214

def self.metric_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:MetricService)
  service_module.const_get(:Client).new(&block)
end

.metric_service_available?(version: :v3) ⇒ boolean

Determines whether the MetricService service is supported by the current client. If true, you can retrieve a client object by calling metric_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the MetricService service, or if the versioned client gem needs an update to support the MetricService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/google/cloud/monitoring.rb', line 236

def self.metric_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :MetricService
  service_module = service_module.const_get :MetricService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.notification_channel_service(version: :v3, &block) ⇒ ::Object

Create a new client object for NotificationChannelService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::NotificationChannelService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the NotificationChannelService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the NotificationChannelService service. You can determine whether the method will succeed by calling notification_channel_service_available?.

About NotificationChannelService

The Notification Channel API provides access to configuration that controls how messages related to incidents are sent.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



276
277
278
279
280
281
282
283
284
285
 
# File 'lib/google/cloud/monitoring.rb', line 276

def self.notification_channel_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:NotificationChannelService)
  service_module.const_get(:Client).new(&block)
end

.notification_channel_service_available?(version: :v3) ⇒ boolean

Determines whether the NotificationChannelService service is supported by the current client. If true, you can retrieve a client object by calling notification_channel_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the NotificationChannelService service, or if the versioned client gem needs an update to support the NotificationChannelService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



298
299
300
301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/google/cloud/monitoring.rb', line 298

def self.notification_channel_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :NotificationChannelService
  service_module = service_module.const_get :NotificationChannelService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.query_service(version: :v3, &block) ⇒ ::Object

Create a new client object for QueryService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::QueryService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the QueryService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the QueryService service. You can determine whether the method will succeed by calling query_service_available?.

About QueryService

The QueryService API is used to manage time series data in Cloud Monitoring. Time series data is a collection of data points that describes the time-varying values of a metric.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



339
340
341
342
343
344
345
346
347
348
 
# File 'lib/google/cloud/monitoring.rb', line 339

def self.query_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:QueryService)
  service_module.const_get(:Client).new(&block)
end

.query_service_available?(version: :v3) ⇒ boolean

Determines whether the QueryService service is supported by the current client. If true, you can retrieve a client object by calling query_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the QueryService service, or if the versioned client gem needs an update to support the QueryService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



361
362
363
364
365
366
367
368
369
370
371
372
373
374
 
# File 'lib/google/cloud/monitoring.rb', line 361

def self.query_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :QueryService
  service_module = service_module.const_get :QueryService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.service_monitoring_service(version: :v3, &block) ⇒ ::Object

Create a new client object for ServiceMonitoringService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::ServiceMonitoringService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the ServiceMonitoringService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the ServiceMonitoringService service. You can determine whether the method will succeed by calling service_monitoring_service_available?.

About ServiceMonitoringService

The Cloud Monitoring Service-Oriented Monitoring API has endpoints for managing and querying aspects of a Metrics Scope's services. These include the Service's monitored resources, its Service-Level Objectives, and a taxonomy of categorized Health Metrics.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



403
404
405
406
407
408
409
410
411
412
 
# File 'lib/google/cloud/monitoring.rb', line 403

def self.service_monitoring_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:ServiceMonitoringService)
  service_module.const_get(:Client).new(&block)
end

.service_monitoring_service_available?(version: :v3) ⇒ boolean

Determines whether the ServiceMonitoringService service is supported by the current client. If true, you can retrieve a client object by calling service_monitoring_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the ServiceMonitoringService service, or if the versioned client gem needs an update to support the ServiceMonitoringService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



425
426
427
428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/google/cloud/monitoring.rb', line 425

def self.service_monitoring_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :ServiceMonitoringService
  service_module = service_module.const_get :ServiceMonitoringService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.snooze_service(version: :v3, &block) ⇒ ::Object

Create a new client object for SnoozeService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::SnoozeService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the SnoozeService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the SnoozeService service. You can determine whether the method will succeed by calling snooze_service_available?.

About SnoozeService

The SnoozeService API is used to temporarily prevent an alert policy from generating alerts. A Snooze is a description of the criteria under which one or more alert policies should not fire alerts for the specified duration.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



466
467
468
469
470
471
472
473
474
475
 
# File 'lib/google/cloud/monitoring.rb', line 466

def self.snooze_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:SnoozeService)
  service_module.const_get(:Client).new(&block)
end

.snooze_service_available?(version: :v3) ⇒ boolean

Determines whether the SnoozeService service is supported by the current client. If true, you can retrieve a client object by calling snooze_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the SnoozeService service, or if the versioned client gem needs an update to support the SnoozeService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



488
489
490
491
492
493
494
495
496
497
498
499
500
501
 
# File 'lib/google/cloud/monitoring.rb', line 488

def self.snooze_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :SnoozeService
  service_module = service_module.const_get :SnoozeService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.uptime_check_service(version: :v3, &block) ⇒ ::Object

Create a new client object for UptimeCheckService.

By default, this returns an instance of Google::Cloud::Monitoring::V3::UptimeCheckService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the UptimeCheckService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

Raises an exception if the currently installed versioned client gem for the given API version does not support the UptimeCheckService service. You can determine whether the method will succeed by calling uptime_check_service_available?.

About UptimeCheckService

The UptimeCheckService API is used to manage (list, create, delete, edit) Uptime check configurations in the Cloud Monitoring product. An Uptime check is a piece of configuration that determines which resources and services to monitor for availability. These configurations can also be configured interactively by navigating to the Cloud console, selecting the appropriate project, clicking on "Monitoring" on the left-hand side to navigate to Cloud Monitoring, and then clicking on "Uptime".

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (::Object) —

    A client object for the specified version.



534
535
536
537
538
539
540
541
542
543
 
# File 'lib/google/cloud/monitoring.rb', line 534

def self.uptime_check_service version: :v3, &block
  require "google/cloud/monitoring/#{version.to_s.downcase}"

  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Monitoring.const_get(package_name).const_get(:UptimeCheckService)
  service_module.const_get(:Client).new(&block)
end

.uptime_check_service_available?(version: :v3) ⇒ boolean

Determines whether the UptimeCheckService service is supported by the current client. If true, you can retrieve a client object by calling uptime_check_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the UptimeCheckService service, or if the versioned client gem needs an update to support the UptimeCheckService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

Returns:

  • (boolean) —

    Whether the service is available.



556
557
558
559
560
561
562
563
564
565
566
567
568
569
 
# File 'lib/google/cloud/monitoring.rb', line 556

def self.uptime_check_service_available? version: :v3
  require "google/cloud/monitoring/#{version.to_s.downcase}"
  package_name = Google::Cloud::Monitoring
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Monitoring.const_get package_name
  return false unless service_module.const_defined? :UptimeCheckService
  service_module = service_module.const_get :UptimeCheckService
  service_module.const_defined? :Client
rescue ::LoadError
  false
end