Class: OCI::StackMonitoring::StackMonitoringClient

Inherits:

Object

Object
OCI::StackMonitoring::StackMonitoringClient

show all

Defined in:: lib/oci/stack_monitoring/stack_monitoring_client.rb

Overview

Stack Monitoring API.

Instance Attribute Summary collapse

#api_client ⇒ OCI::ApiClient readonly

Client used to make HTTP requests.
#endpoint ⇒ String readonly

Fully qualified endpoint URL.
#region ⇒ String

The region, which will usually correspond to a value in Regions::REGION_ENUM.
#retry_config ⇒ OCI::Retry::RetryConfig readonly

The default retry configuration to apply to all operations in this service client.

Instance Method Summary collapse

#associate_monitored_resources(associate_monitored_resources_details, opts = {}) ⇒ Response

Create an association between two monitored resources.
#change_config_compartment(config_id, change_config_compartment_details, opts = {}) ⇒ Response

Moves the configuration item to another compartment.
#change_metric_extension_compartment(metric_extension_id, change_metric_extension_compartment_details, opts = {}) ⇒ Response

Moves a Metric Extension resource from one compartment identifier to another.
#change_monitored_resource_compartment(monitored_resource_id, change_monitored_resource_compartment_details, opts = {}) ⇒ Response

Moves a monitored resource from one compartment to another.
#change_monitored_resource_task_compartment(monitored_resource_task_id, change_monitored_resource_task_compartment_details, opts = {}) ⇒ Response

Moves a stack monitoring resource task from one compartment to another.
#change_process_set_compartment(process_set_id, change_process_set_compartment_details, opts = {}) ⇒ Response

Moves a ProcessSet resource from one compartment identifier to another.
#create_baselineable_metric(create_baselineable_metric_details, opts = {}) ⇒ Response

Creates the specified Baseline-able metric.
#create_config(create_config_details, opts = {}) ⇒ Response

Creates a configuration item, for example to define whether resources of a specific type should be discovered automatically.
#create_discovery_job(create_discovery_job_details, opts = {}) ⇒ Response

API to create discovery Job and submit discovery Details to agent.
#create_metric_extension(create_metric_extension_details, opts = {}) ⇒ Response

Creates a new metric extension resource for a given compartment.
#create_monitored_resource(create_monitored_resource_details, opts = {}) ⇒ Response

Creates a new monitored resource for the given resource type with the details and submits a work request for promoting the resource to agent.
#create_monitored_resource_task(create_monitored_resource_task_details, opts = {}) ⇒ Response

Create a new stack monitoring resource task.
#create_monitored_resource_type(create_monitored_resource_type_details, opts = {}) ⇒ Response

Creates a new monitored resource type.
#create_process_set(create_process_set_details, opts = {}) ⇒ Response

API to create Process Set.
#delete_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ Response

Deletes the Baseline-able metric for the given id.
#delete_config(config_id, opts = {}) ⇒ Response

Deletes a configuration identified by the id.
#delete_discovery_job(discovery_job_id, opts = {}) ⇒ Response

Deletes a DiscoveryJob by identifier.
#delete_metric_extension(metric_extension_id, opts = {}) ⇒ Response

Deletes a metric extension by identifier.
#delete_monitored_resource(monitored_resource_id, opts = {}) ⇒ Response

Delete monitored resource by the given identifier OCID.
#delete_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ Response

Deletes a monitored resource type by identifier OCID.
#delete_process_set(process_set_id, opts = {}) ⇒ Response

Deletes a Process Set.
#disable_external_database(monitored_resource_id, opts = {}) ⇒ Response

Disable external database resource monitoring.
#disable_metric_extension(metric_extension_id, disable_metric_extension_details, opts = {}) ⇒ Response

Submits a request to disable matching metric extension Id for the given Resource IDs.
#disassociate_monitored_resources(disassociate_monitored_resources_details, opts = {}) ⇒ Response

Removes associations between two monitored resources.
#enable_metric_extension(metric_extension_id, enable_metric_extension_details, opts = {}) ⇒ Response

Submits a request to enable matching metric extension Id for the given Resource IDs.
#evaluate_baselineable_metric(evaluate_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ Response

Evaluates metric for anomalies for the given data points.
#export_metric_extension(metric_extension_id, opts = {}, &block) ⇒ Response

Export generates a template used to create new metric extension resources similar to matching metric extension id.
#get_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ Response

Get the Baseline-able metric for the given id.
#get_config(config_id, opts = {}) ⇒ Response

Gets the details of a configuration.
#get_discovery_job(discovery_job_id, opts = {}) ⇒ Response

API to get the details of discovery Job by identifier.
#get_metric_extension(metric_extension_id, opts = {}) ⇒ Response

Gets a Metric Extension by identifier.
#get_monitored_resource(monitored_resource_id, opts = {}) ⇒ Response

Get monitored resource for the given identifier OCID.
#get_monitored_resource_task(monitored_resource_task_id, opts = {}) ⇒ Response

Gets stack monitoring resource task details by identifier OCID.
#get_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ Response

Gets a monitored resource type by identifier OCID.
#get_process_set(process_set_id, opts = {}) ⇒ Response

API to get the details of a Process Set by identifier.
#get_work_request(work_request_id, opts = {}) ⇒ Response

Gets the status of the work request with the given ID.
#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ StackMonitoringClient constructor

Creates a new StackMonitoringClient.
#list_baselineable_metrics(opts = {}) ⇒ Response

List of summary of baseline-able metrics for a given resource group if specified.
#list_configs(compartment_id, opts = {}) ⇒ Response

Get a list of configurations in a compartment.
#list_discovery_job_logs(discovery_job_id, opts = {}) ⇒ Response

API to get all the logs of a Discovery Job.
#list_discovery_jobs(compartment_id, opts = {}) ⇒ Response

API to get the details of all Discovery Jobs.
#list_metric_extensions(compartment_id, opts = {}) ⇒ Response

Returns a list of metric extensions.
#list_monitored_resource_tasks(compartment_id, opts = {}) ⇒ Response

Returns a list of stack monitoring resource tasks in the compartment.
#list_monitored_resource_types(compartment_id, opts = {}) ⇒ Response

Returns list of resource types accessible to the customer.
#list_monitored_resources(compartment_id, opts = {}) ⇒ Response

Returns a list of monitored resources.
#list_process_sets(compartment_id, opts = {}) ⇒ Response

API to get the details of all Process Sets.
#list_work_request_errors(work_request_id, opts = {}) ⇒ Response

Return a (paginated) list of errors for a given work request.
#list_work_request_logs(work_request_id, opts = {}) ⇒ Response

Return a (paginated) list of logs for a given work request.
#list_work_requests(compartment_id, opts = {}) ⇒ Response

Lists the work requests in a compartment.
#logger ⇒ Logger

The logger for this client.
#manage_license(monitored_resource_id, manage_license_details, opts = {}) ⇒ Response

Each resource is assigned a license based on which features are enabled for it.
#publish_metric_extension(metric_extension_id, opts = {}) ⇒ Response

Publish the Metric Extension identified by the id.
#request_monitored_resources_summarized_count(compartment_id, opts = {}) ⇒ Response

Gets resource count based on the aggregation criteria specified using "groupBy" parameter.
#search_associated_resources(search_associated_resources_details, opts = {}) ⇒ Response

List all associated resources recursively up-to a specified level, for the monitored resources of type specified.
#search_monitored_resource_associations(search_monitored_resource_associations_details, opts = {}) ⇒ Response

Search associations in the given compartment based on the search criteria.
#search_monitored_resource_members(monitored_resource_id, search_monitored_resource_members_details, opts = {}) ⇒ Response

List the member resources for the given monitored resource identifier OCID.
#search_monitored_resources(search_monitored_resources_details, opts = {}) ⇒ Response

Gets a list of all monitored resources in a compartment for the given search criteria.
#test_metric_extension(metric_extension_id, test_metric_extension_details, opts = {}) ⇒ Response

Performs test of Metric Extension on a specific resource Id.
#update_and_propagate_tags(monitored_resource_id, update_and_propagate_tags_details, opts = {}) ⇒ Response

Provided tags will be added or updated in the existing list of tags for the affected resources.
#update_baselineable_metric(update_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ Response

Updates the Baseline-able metric for the given id.
#update_config(config_id, update_config_details, opts = {}) ⇒ Response

Updates the configuration identified by the id given.
#update_metric_extension(metric_extension_id, update_metric_extension_details, opts = {}) ⇒ Response

Updates the Metric Extension.
#update_monitored_resource(monitored_resource_id, update_monitored_resource_details, opts = {}) ⇒ Response

Update monitored resource by the given identifier OCID.
#update_monitored_resource_task(monitored_resource_task_id, update_monitored_resource_task_details, opts = {}) ⇒ Response

Update stack monitoring resource task by the given identifier OCID.
#update_monitored_resource_type(monitored_resource_type_id, update_monitored_resource_type_details, opts = {}) ⇒ Response

Update the Monitored Resource Type identified by the identifier OCID.
#update_process_set(process_set_id, update_process_set_details, opts = {}) ⇒ Response

API to update a Process Set identified by a given ocid.

Constructor Details

#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ `StackMonitoringClient`

Creates a new StackMonitoringClient. Notes: If a config is not specified, then the global OCI.config will be used.

This client is not thread-safe

Either a region or an endpoint must be specified. If an endpoint is specified, it will be used instead of the region. A region may be specified in the config or via or the region parameter. If specified in both, then the region parameter will be used.

Parameters:

config (Config) (defaults to: nil) —

A Config object.
region (String) (defaults to: nil) —

A region used to determine the service endpoint. This will usually correspond to a value in Regions::REGION_ENUM, but may be an arbitrary string.
endpoint (String) (defaults to: nil) —

The fully qualified endpoint URL
signer (OCI::BaseSigner) (defaults to: nil) —

A signer implementation which can be used by this client. If this is not provided then a signer will be constructed via the provided config. One use case of this parameter is instance principals authentication, so that the instance principals signer can be provided to the client
proxy_settings (OCI::ApiClientProxySettings) (defaults to: nil) —

If your environment requires you to use a proxy server for outgoing HTTP requests the details for the proxy can be provided in this parameter
retry_config (OCI::Retry::RetryConfig) (defaults to: nil) —

The retry configuration for this service client. This represents the default retry configuration to apply across all operations. This can be overridden on a per-operation basis. The default retry configuration value is nil, which means that an operation will not perform any retries

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 55

def initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil)
  # If the signer is an InstancePrincipalsSecurityTokenSigner or SecurityTokenSigner and no config was supplied (they are self-sufficient signers)
  # then create a dummy config to pass to the ApiClient constructor. If customers wish to create a client which uses instance principals
  # and has config (either populated programmatically or loaded from a file), they must construct that config themselves and then
  # pass it to this constructor.
  #
  # If there is no signer (or the signer is not an instance principals signer) and no config was supplied, this is not valid
  # so try and load the config from the default file.
  config = OCI::Config.validate_and_build_config_with_signer(config, signer)

  signer = OCI::Signer.config_file_auth_builder(config) if signer.nil?

  @api_client = OCI::ApiClient.new(config, signer, proxy_settings: proxy_settings)
  @retry_config = retry_config

  if endpoint
    @endpoint = endpoint + '/20210330'
  else
    region ||= config.region
    region ||= signer.region if signer.respond_to?(:region)
    self.region = region
  end
  logger.info "StackMonitoringClient endpoint set to '#{@endpoint}'." if logger
end

Instance Attribute Details

#api_client ⇒ `OCI::ApiClient` (readonly)

Client used to make HTTP requests.

Returns:

(OCI::ApiClient)



15
16
17

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 15

def api_client
  @api_client
end

#endpoint ⇒ `String` (readonly)

Fully qualified endpoint URL

Returns:

(String)



19
20
21

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 19

def endpoint
  @endpoint
end

#region ⇒ `String`

The region, which will usually correspond to a value in Regions::REGION_ENUM.

Returns:

(String)



29
30
31

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 29

def region
  @region
end

#retry_config ⇒ `OCI::Retry::RetryConfig` (readonly)

The default retry configuration to apply to all operations in this service client. This can be overridden on a per-operation basis. The default retry configuration value is nil, which means that an operation will not perform any retries

Returns:

(OCI::Retry::RetryConfig)



25
26
27

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 25

def retry_config
  @retry_config
end

Instance Method Details

#associate_monitored_resources(associate_monitored_resources_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use associate_monitored_resources API.

Create an association between two monitored resources. Associations can be created between resources from different compartments as long they are in same tenancy. User should have required access in both the compartments.

Parameters:

associate_monitored_resources_details (OCI::StackMonitoring::Models::AssociateMonitoredResourcesDetails) —

Details to create association between two resources.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type MonitoredResourceAssociation

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 129

def associate_monitored_resources(associate_monitored_resources_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#associate_monitored_resources.' if logger

  raise "Missing the required parameter 'associate_monitored_resources_details' when calling associate_monitored_resources." if associate_monitored_resources_details.nil?

  path = '/monitoredResources/actions/associateMonitoredResources'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(associate_monitored_resources_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#associate_monitored_resources') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceAssociation'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#change_config_compartment(config_id, change_config_compartment_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use change_config_compartment API.

Moves the configuration item to another compartment. Basically, this will disable any configuration for this configuration type in thie compartment, and will enable it in the new one.

For example, if for a HOST resource type, the configuration with AUTO_PROMOTE in the configuration type and TRUE as value is moved, automatic discovery will not take place in this compartment any more, but in the new one.

So this operation will have the same effect as deleting the configuration item in the old compartment and recreating it in another compartment.

When provided, If-Match is checked against ETag values of the resource.

Parameters:

config_id (String) —

Unique Config identifier.
change_config_compartment_details (OCI::StackMonitoring::Models::ChangeConfigCompartmentDetails) —

Details for the compartment move.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 211

def change_config_compartment(config_id, change_config_compartment_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#change_config_compartment.' if logger

  raise "Missing the required parameter 'config_id' when calling change_config_compartment." if config_id.nil?
  raise "Missing the required parameter 'change_config_compartment_details' when calling change_config_compartment." if change_config_compartment_details.nil?
  raise "Parameter value for 'config_id' must not be blank" if OCI::Internal::Util.blank_string?(config_id)

  path = '/configs/{configId}/actions/changeCompartment'.sub('{configId}', config_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(change_config_compartment_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#change_config_compartment') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#change_metric_extension_compartment(metric_extension_id, change_metric_extension_compartment_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use change_metric_extension_compartment API.

Moves a Metric Extension resource from one compartment identifier to another. When provided, If-Match is checked against ETag values of the resource.

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
change_metric_extension_compartment_details (OCI::StackMonitoring::Models::ChangeMetricExtensionCompartmentDetails) —

The information required to change compartment of given Metric Extension resource
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 285

def change_metric_extension_compartment(metric_extension_id, change_metric_extension_compartment_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#change_metric_extension_compartment.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling change_metric_extension_compartment." if metric_extension_id.nil?
  raise "Missing the required parameter 'change_metric_extension_compartment_details' when calling change_metric_extension_compartment." if change_metric_extension_compartment_details.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}/actions/changeCompartment'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(change_metric_extension_compartment_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#change_metric_extension_compartment') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#change_monitored_resource_compartment(monitored_resource_id, change_monitored_resource_compartment_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use change_monitored_resource_compartment API.

Moves a monitored resource from one compartment to another. When provided, If-Match is checked against ETag values of the resource.

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
change_monitored_resource_compartment_details (OCI::StackMonitoring::Models::ChangeMonitoredResourceCompartmentDetails) —

The information to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 359

def change_monitored_resource_compartment(monitored_resource_id, change_monitored_resource_compartment_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#change_monitored_resource_compartment.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling change_monitored_resource_compartment." if monitored_resource_id.nil?
  raise "Missing the required parameter 'change_monitored_resource_compartment_details' when calling change_monitored_resource_compartment." if change_monitored_resource_compartment_details.nil?
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}/actions/changeCompartment'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(change_monitored_resource_compartment_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#change_monitored_resource_compartment') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#change_monitored_resource_task_compartment(monitored_resource_task_id, change_monitored_resource_task_compartment_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use change_monitored_resource_task_compartment API.

Moves a stack monitoring resource task from one compartment to another.

Parameters:

monitored_resource_task_id (String) —

The OCID of stack monitoring resource task.
change_monitored_resource_task_compartment_details (OCI::StackMonitoring::Models::ChangeMonitoredResourceTaskCompartmentDetails) —

The information to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 432

def change_monitored_resource_task_compartment(monitored_resource_task_id, change_monitored_resource_task_compartment_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#change_monitored_resource_task_compartment.' if logger

  raise "Missing the required parameter 'monitored_resource_task_id' when calling change_monitored_resource_task_compartment." if monitored_resource_task_id.nil?
  raise "Missing the required parameter 'change_monitored_resource_task_compartment_details' when calling change_monitored_resource_task_compartment." if change_monitored_resource_task_compartment_details.nil?
  raise "Parameter value for 'monitored_resource_task_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_task_id)

  path = '/monitoredResourceTasks/{monitoredResourceTaskId}/actions/changeCompartment'.sub('{monitoredResourceTaskId}', monitored_resource_task_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(change_monitored_resource_task_compartment_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#change_monitored_resource_task_compartment') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#change_process_set_compartment(process_set_id, change_process_set_compartment_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use change_process_set_compartment API.

Moves a ProcessSet resource from one compartment identifier to another. When provided, If-Match is checked against ETag values of the resource.

Parameters:

process_set_id (String) —

The Process Set ID
change_process_set_compartment_details (OCI::StackMonitoring::Models::ChangeProcessSetCompartmentDetails) —

The information to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 505

def change_process_set_compartment(process_set_id, change_process_set_compartment_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#change_process_set_compartment.' if logger

  raise "Missing the required parameter 'process_set_id' when calling change_process_set_compartment." if process_set_id.nil?
  raise "Missing the required parameter 'change_process_set_compartment_details' when calling change_process_set_compartment." if change_process_set_compartment_details.nil?
  raise "Parameter value for 'process_set_id' must not be blank" if OCI::Internal::Util.blank_string?(process_set_id)

  path = '/processSets/{processSetId}/actions/changeCompartment'.sub('{processSetId}', process_set_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(change_process_set_compartment_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#change_process_set_compartment') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_baselineable_metric(create_baselineable_metric_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_baselineable_metric API.

Creates the specified Baseline-able metric

Parameters:

create_baselineable_metric_details (OCI::StackMonitoring::Models::CreateBaselineableMetricDetails) —

Baseline metric
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type BaselineableMetric

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 570

def create_baselineable_metric(create_baselineable_metric_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_baselineable_metric.' if logger

  raise "Missing the required parameter 'create_baselineable_metric_details' when calling create_baselineable_metric." if create_baselineable_metric_details.nil?

  path = '/baselineableMetrics'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_baselineable_metric_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_baselineable_metric') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::BaselineableMetric'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_config(create_config_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_config API.

Creates a configuration item, for example to define whether resources of a specific type should be discovered automatically.

For example, when a new Management Agent gets registered in a certain compartment, this Management Agent can potentially get promoted to a HOST resource. The configuration item will determine if HOST resources in the selected compartment will be discovered automatically.

Parameters:

create_config_details (OCI::StackMonitoring::Models::CreateConfigDetails) —

Details for the new configuration.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type Config

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 640

def create_config(create_config_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_config.' if logger

  raise "Missing the required parameter 'create_config_details' when calling create_config." if create_config_details.nil?

  path = '/configs'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_config_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_config') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::Config'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_discovery_job(create_discovery_job_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_discovery_job API.

API to create discovery Job and submit discovery Details to agent.

Parameters:

create_discovery_job_details (OCI::StackMonitoring::Models::CreateDiscoveryJobDetails) —

Summary of source and credential discovery details.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type DiscoveryJob

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 704

def create_discovery_job(create_discovery_job_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_discovery_job.' if logger

  raise "Missing the required parameter 'create_discovery_job_details' when calling create_discovery_job." if create_discovery_job_details.nil?

  path = '/discoveryJobs'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_discovery_job_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_discovery_job') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::DiscoveryJob'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_metric_extension(create_metric_extension_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_metric_extension API.

Creates a new metric extension resource for a given compartment

Parameters:

create_metric_extension_details (OCI::StackMonitoring::Models::CreateMetricExtensionDetails) —

Details required for creating new Metric Extension
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MetricExtension

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 768

def create_metric_extension(create_metric_extension_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_metric_extension.' if logger

  raise "Missing the required parameter 'create_metric_extension_details' when calling create_metric_extension." if create_metric_extension_details.nil?

  path = '/metricExtensions'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_metric_extension_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_metric_extension') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MetricExtension'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_monitored_resource(create_monitored_resource_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_monitored_resource API.

Creates a new monitored resource for the given resource type with the details and submits a work request for promoting the resource to agent. Once the resource is successfully added to agent, resource state will be marked active.

Parameters:

create_monitored_resource_details (OCI::StackMonitoring::Models::CreateMonitoredResourceDetails) —

Details for the new monitored resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:external_resource_id (String) —

Generally used by DBaaS to send the Database OCID stored on the DBaaS. The same will be passed to resource service to enable Stack Monitoring Service on DBM. This will be stored in Stack Monitoring Resource Service data store as identifier for monitored resource. If this header is not set as part of the request, then an id will be generated and stored for the resource.

Returns:

(Response) —

A Response object with data of type MonitoredResource

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 840

def create_monitored_resource(create_monitored_resource_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_monitored_resource.' if logger

  raise "Missing the required parameter 'create_monitored_resource_details' when calling create_monitored_resource." if create_monitored_resource_details.nil?

  path = '/monitoredResources'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'external-resource-id'] = opts[:external_resource_id] if opts[:external_resource_id]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_monitored_resource_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_monitored_resource') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResource'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_monitored_resource_task(create_monitored_resource_task_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_monitored_resource_task API.

Create a new stack monitoring resource task.

Parameters:

create_monitored_resource_task_details (OCI::StackMonitoring::Models::CreateMonitoredResourceTaskDetails) —

Details to create the new stack monitoring resource task.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type MonitoredResourceTask

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 904

def create_monitored_resource_task(create_monitored_resource_task_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_monitored_resource_task.' if logger

  raise "Missing the required parameter 'create_monitored_resource_task_details' when calling create_monitored_resource_task." if create_monitored_resource_task_details.nil?

  path = '/monitoredResourceTasks'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_monitored_resource_task_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_monitored_resource_task') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceTask'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_monitored_resource_type(create_monitored_resource_type_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_monitored_resource_type API.

Creates a new monitored resource type.

Parameters:

create_monitored_resource_type_details (OCI::StackMonitoring::Models::CreateMonitoredResourceTypeDetails) —

Details for the new monitored resource type.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type MonitoredResourceType

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 967

def create_monitored_resource_type(create_monitored_resource_type_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_monitored_resource_type.' if logger

  raise "Missing the required parameter 'create_monitored_resource_type_details' when calling create_monitored_resource_type." if create_monitored_resource_type_details.nil?

  path = '/monitoredResourceTypes'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_monitored_resource_type_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_monitored_resource_type') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceType'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_process_set(create_process_set_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use create_process_set API.

API to create Process Set.

Parameters:

create_process_set_details (OCI::StackMonitoring::Models::CreateProcessSetDetails) —

Summary of process set details.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type ProcessSet

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1030

def create_process_set(create_process_set_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#create_process_set.' if logger

  raise "Missing the required parameter 'create_process_set_details' when calling create_process_set." if create_process_set_details.nil?

  path = '/processSets'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_process_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#create_process_set') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::ProcessSet'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use delete_baselineable_metric API.

Deletes the Baseline-able metric for the given id

Parameters:

baselineable_metric_id (String) —

Identifier for the metric
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1093

def delete_baselineable_metric(baselineable_metric_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#delete_baselineable_metric.' if logger

  raise "Missing the required parameter 'baselineable_metric_id' when calling delete_baselineable_metric." if baselineable_metric_id.nil?
  raise "Parameter value for 'baselineable_metric_id' must not be blank" if OCI::Internal::Util.blank_string?(baselineable_metric_id)

  path = '/baselineableMetrics/{baselineableMetricId}'.sub('{baselineableMetricId}', baselineable_metric_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#delete_baselineable_metric') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_config(config_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use delete_config API.

Deletes a configuration identified by the id.

Parameters:

config_id (String) —

Unique Config identifier.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1155

def delete_config(config_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#delete_config.' if logger

  raise "Missing the required parameter 'config_id' when calling delete_config." if config_id.nil?
  raise "Parameter value for 'config_id' must not be blank" if OCI::Internal::Util.blank_string?(config_id)

  path = '/configs/{configId}'.sub('{configId}', config_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#delete_config') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_discovery_job(discovery_job_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use delete_discovery_job API.

Deletes a DiscoveryJob by identifier

Parameters:

discovery_job_id (String) —

The Discovery Job ID
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1217

def delete_discovery_job(discovery_job_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#delete_discovery_job.' if logger

  raise "Missing the required parameter 'discovery_job_id' when calling delete_discovery_job." if discovery_job_id.nil?
  raise "Parameter value for 'discovery_job_id' must not be blank" if OCI::Internal::Util.blank_string?(discovery_job_id)

  path = '/discoveryJobs/{discoveryJobId}'.sub('{discoveryJobId}', discovery_job_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#delete_discovery_job') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_metric_extension(metric_extension_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use delete_metric_extension API.

Deletes a metric extension by identifier

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1279

def delete_metric_extension(metric_extension_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#delete_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling delete_metric_extension." if metric_extension_id.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#delete_metric_extension') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_monitored_resource(monitored_resource_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use delete_monitored_resource API.

Delete monitored resource by the given identifier OCID. By default, only the specified resource is deleted. If the parameter 'isDeleteMembers' is set to true, then the member resources will be deleted too. If the operation fails partially, the deleted entries will not be rolled back.

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:is_delete_members (BOOLEAN) —

If this query parameter is specified and set to true, all the member resources will be deleted before deleting the specified resource. (default to false)

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1348

def delete_monitored_resource(monitored_resource_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#delete_monitored_resource.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling delete_monitored_resource." if monitored_resource_id.nil?
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:isDeleteMembers] = opts[:is_delete_members] if !opts[:is_delete_members].nil?

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#delete_monitored_resource') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use delete_monitored_resource_type API.

Deletes a monitored resource type by identifier OCID.

Parameters:

monitored_resource_type_id (String) —

The OCID of monitored resource type.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1411

def delete_monitored_resource_type(monitored_resource_type_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#delete_monitored_resource_type.' if logger

  raise "Missing the required parameter 'monitored_resource_type_id' when calling delete_monitored_resource_type." if monitored_resource_type_id.nil?
  raise "Parameter value for 'monitored_resource_type_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_type_id)

  path = '/monitoredResourceTypes/{monitoredResourceTypeId}'.sub('{monitoredResourceTypeId}', monitored_resource_type_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#delete_monitored_resource_type') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_process_set(process_set_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use delete_process_set API.

Deletes a Process Set

Parameters:

process_set_id (String) —

The Process Set ID
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1473

def delete_process_set(process_set_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#delete_process_set.' if logger

  raise "Missing the required parameter 'process_set_id' when calling delete_process_set." if process_set_id.nil?
  raise "Parameter value for 'process_set_id' must not be blank" if OCI::Internal::Util.blank_string?(process_set_id)

  path = '/processSets/{processSetId}'.sub('{processSetId}', process_set_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#delete_process_set') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#disable_external_database(monitored_resource_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use disable_external_database API.

Disable external database resource monitoring. All the references in DBaaS, DBM and resource service will be deleted as part of this operation.

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1543

def disable_external_database(monitored_resource_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#disable_external_database.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling disable_external_database." if monitored_resource_id.nil?
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}/actions/disableExternalDatabase'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#disable_external_database') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#disable_metric_extension(metric_extension_id, disable_metric_extension_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use disable_metric_extension API.

Submits a request to disable matching metric extension Id for the given Resource IDs

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
disable_metric_extension_details (OCI::StackMonitoring::Models::DisableMetricExtensionDetails) —

The list of Resource IDs for which given metric extension needs to be disabled
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1615

def disable_metric_extension(metric_extension_id, disable_metric_extension_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#disable_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling disable_metric_extension." if metric_extension_id.nil?
  raise "Missing the required parameter 'disable_metric_extension_details' when calling disable_metric_extension." if disable_metric_extension_details.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}/actions/disable'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(disable_metric_extension_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#disable_metric_extension') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#disassociate_monitored_resources(disassociate_monitored_resources_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use disassociate_monitored_resources API.

Removes associations between two monitored resources.

Parameters:

disassociate_monitored_resources_details (OCI::StackMonitoring::Models::DisassociateMonitoredResourcesDetails) —

Disassociate resources.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1686

def disassociate_monitored_resources(disassociate_monitored_resources_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#disassociate_monitored_resources.' if logger

  raise "Missing the required parameter 'disassociate_monitored_resources_details' when calling disassociate_monitored_resources." if disassociate_monitored_resources_details.nil?

  path = '/monitoredResources/actions/disassociateMonitoredResources'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(disassociate_monitored_resources_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#disassociate_monitored_resources') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#enable_metric_extension(metric_extension_id, enable_metric_extension_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use enable_metric_extension API.

Submits a request to enable matching metric extension Id for the given Resource IDs

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
enable_metric_extension_details (OCI::StackMonitoring::Models::EnableMetricExtensionDetails) —

The list of Resource IDs for which given metric extension needs to be enabled
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1757

def enable_metric_extension(metric_extension_id, enable_metric_extension_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#enable_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling enable_metric_extension." if metric_extension_id.nil?
  raise "Missing the required parameter 'enable_metric_extension_details' when calling enable_metric_extension." if enable_metric_extension_details.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}/actions/enable'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(enable_metric_extension_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#enable_metric_extension') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#evaluate_baselineable_metric(evaluate_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use evaluate_baselineable_metric API.

Evaluates metric for anomalies for the given data points

Parameters:

evaluate_baselineable_metric_details (OCI::StackMonitoring::Models::EvaluateBaselineableMetricDetails) —

Metric details
baselineable_metric_id (String) —

Identifier for the metric
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type EvaluateBaselineableMetricResult

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1829

def evaluate_baselineable_metric(evaluate_baselineable_metric_details, baselineable_metric_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#evaluate_baselineable_metric.' if logger

  raise "Missing the required parameter 'evaluate_baselineable_metric_details' when calling evaluate_baselineable_metric." if evaluate_baselineable_metric_details.nil?
  raise "Missing the required parameter 'baselineable_metric_id' when calling evaluate_baselineable_metric." if baselineable_metric_id.nil?
  raise "Parameter value for 'baselineable_metric_id' must not be blank" if OCI::Internal::Util.blank_string?(baselineable_metric_id)

  path = '/baselineableMetrics/{baselineableMetricId}/actions/evaluate'.sub('{baselineableMetricId}', baselineable_metric_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(evaluate_baselineable_metric_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#evaluate_baselineable_metric') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::EvaluateBaselineableMetricResult'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#export_metric_extension(metric_extension_id, opts = {}, &block) ⇒ `Response`

Note:

Click here to see an example of how to use export_metric_extension API.

Export generates a template used to create new metric extension resources similar to matching metric extension id. Response is a file that contains metric extension definition with placeholders for fields to be changed.

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
opts (Hash) (defaults to: {}) —

the optional parameters
[Block] (Hash) —

a customizable set of options

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:response_target (String, IO) —

Streaming http body into a file (specified by file name or File object) or IO object if the block is not given

Returns:

(Response) —

A Response object with data of type String if response_target and block are not given, otherwise with nil data

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 1905

def export_metric_extension(metric_extension_id, opts = {}, &block)
  logger.debug 'Calling operation StackMonitoringClient#export_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling export_metric_extension." if metric_extension_id.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}/actions/export'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = opts[:accept] if opts[:accept]
  header_params[:accept] ||= 'application/json'
  header_params[:'accept-encoding'] = opts[:accept_encoding] if opts[:accept_encoding]
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#export_metric_extension') do
    if !block.nil?
      @api_client.call_api(
        :POST,
        path,
        endpoint,
        header_params: header_params,
        query_params: query_params,
        operation_signing_strategy: operation_signing_strategy,
        body: post_body,
        return_type: 'Stream',
        &block
      )
    elsif opts[:response_target]
      if opts[:response_target].respond_to? :write
        @api_client.call_api(
          :POST,
          path,
          endpoint,
          header_params: header_params,
          query_params: query_params,
          operation_signing_strategy: operation_signing_strategy,
          body: post_body,
          return_type: 'Stream',
          &proc { |chunk, _response| opts[:response_target].write(chunk) }
        )
      elsif opts[:response_target].is_a?(String)
        File.open(opts[:response_target], 'wb') do |output|
          return @api_client.call_api(
            :POST,
            path,
            endpoint,
            header_params: header_params,
            query_params: query_params,
            operation_signing_strategy: operation_signing_strategy,
            body: post_body,
            return_type: 'Stream',
            &proc { |chunk, _response| output.write(chunk) }
          )
        end
      end
    else
      @api_client.call_api(
        :POST,
        path,
        endpoint,
        header_params: header_params,
        query_params: query_params,
        operation_signing_strategy: operation_signing_strategy,
        body: post_body,
        return_type: 'String'
      )
    end
  end
  # rubocop:enable Metrics/BlockLength
end

#get_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_baselineable_metric API.

Get the Baseline-able metric for the given id

Parameters:

baselineable_metric_id (String) —

Identifier for the metric
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type BaselineableMetric

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2008

def get_baselineable_metric(baselineable_metric_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_baselineable_metric.' if logger

  raise "Missing the required parameter 'baselineable_metric_id' when calling get_baselineable_metric." if baselineable_metric_id.nil?
  raise "Parameter value for 'baselineable_metric_id' must not be blank" if OCI::Internal::Util.blank_string?(baselineable_metric_id)

  path = '/baselineableMetrics/{baselineableMetricId}'.sub('{baselineableMetricId}', baselineable_metric_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_baselineable_metric') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::BaselineableMetric'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_config(config_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_config API.

Gets the details of a configuration.

Parameters:

config_id (String) —

Unique Config identifier.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type Config

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2064

def get_config(config_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_config.' if logger

  raise "Missing the required parameter 'config_id' when calling get_config." if config_id.nil?
  raise "Parameter value for 'config_id' must not be blank" if OCI::Internal::Util.blank_string?(config_id)

  path = '/configs/{configId}'.sub('{configId}', config_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_config') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::Config'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_discovery_job(discovery_job_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_discovery_job API.

API to get the details of discovery Job by identifier.

Parameters:

discovery_job_id (String) —

The Discovery Job ID
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type DiscoveryJob

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2121

def get_discovery_job(discovery_job_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_discovery_job.' if logger

  raise "Missing the required parameter 'discovery_job_id' when calling get_discovery_job." if discovery_job_id.nil?
  raise "Parameter value for 'discovery_job_id' must not be blank" if OCI::Internal::Util.blank_string?(discovery_job_id)

  path = '/discoveryJobs/{discoveryJobId}'.sub('{discoveryJobId}', discovery_job_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_discovery_job') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::DiscoveryJob'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_metric_extension(metric_extension_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_metric_extension API.

Gets a Metric Extension by identifier

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MetricExtension

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2177

def get_metric_extension(metric_extension_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling get_metric_extension." if metric_extension_id.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_metric_extension') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MetricExtension'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_monitored_resource(monitored_resource_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_monitored_resource API.

Get monitored resource for the given identifier OCID.

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResource

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2234

def get_monitored_resource(monitored_resource_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_monitored_resource.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling get_monitored_resource." if monitored_resource_id.nil?
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_monitored_resource') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResource'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_monitored_resource_task(monitored_resource_task_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_monitored_resource_task API.

Gets stack monitoring resource task details by identifier OCID.

Parameters:

monitored_resource_task_id (String) —

The OCID of stack monitoring resource task.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResourceTask

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2290

def get_monitored_resource_task(monitored_resource_task_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_monitored_resource_task.' if logger

  raise "Missing the required parameter 'monitored_resource_task_id' when calling get_monitored_resource_task." if monitored_resource_task_id.nil?
  raise "Parameter value for 'monitored_resource_task_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_task_id)

  path = '/monitoredResourceTasks/{monitoredResourceTaskId}'.sub('{monitoredResourceTaskId}', monitored_resource_task_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_monitored_resource_task') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceTask'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_monitored_resource_type API.

Gets a monitored resource type by identifier OCID.

Parameters:

monitored_resource_type_id (String) —

The OCID of monitored resource type.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResourceType

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2346

def get_monitored_resource_type(monitored_resource_type_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_monitored_resource_type.' if logger

  raise "Missing the required parameter 'monitored_resource_type_id' when calling get_monitored_resource_type." if monitored_resource_type_id.nil?
  raise "Parameter value for 'monitored_resource_type_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_type_id)

  path = '/monitoredResourceTypes/{monitoredResourceTypeId}'.sub('{monitoredResourceTypeId}', monitored_resource_type_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_monitored_resource_type') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceType'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_process_set(process_set_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_process_set API.

API to get the details of a Process Set by identifier.

Parameters:

process_set_id (String) —

The Process Set ID
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type ProcessSet

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2402

def get_process_set(process_set_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_process_set.' if logger

  raise "Missing the required parameter 'process_set_id' when calling get_process_set." if process_set_id.nil?
  raise "Parameter value for 'process_set_id' must not be blank" if OCI::Internal::Util.blank_string?(process_set_id)

  path = '/processSets/{processSetId}'.sub('{processSetId}', process_set_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_process_set') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::ProcessSet'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_work_request(work_request_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use get_work_request API.

Gets the status of the work request with the given ID.

Parameters:

work_request_id (String) —

The OCID of the work request.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type WorkRequest

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2458

def get_work_request(work_request_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#get_work_request.' if logger

  raise "Missing the required parameter 'work_request_id' when calling get_work_request." if work_request_id.nil?
  raise "Parameter value for 'work_request_id' must not be blank" if OCI::Internal::Util.blank_string?(work_request_id)

  path = '/workRequests/{workRequestId}'.sub('{workRequestId}', work_request_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#get_work_request') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::WorkRequest'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_baselineable_metrics(opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_baselineable_metrics API.

List of summary of baseline-able metrics for a given resource group if specified. Allowed values are: name, namespace, resourceGroup

Parameters:

opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:resource_group (String) —

Resource Group
:name (String) —

Metric Name
:metric_namespace (String) —

A filter to return monitored resource types that has the matching namespace.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:compartment_id (String) —

The ID of the compartment in which data is listed.
:baselineable_metric_id (String) —

Identifier for the metric
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order is ascending. (default to name)

Returns:

(Response) —

A Response object with data of type BaselineableMetricSummaryCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2532

def list_baselineable_metrics(opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_baselineable_metrics.' if logger


  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[name namespace resourceGroup].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of name, namespace, resourceGroup.'
  end

  path = '/baselineableMetrics'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:resourceGroup] = opts[:resource_group] if opts[:resource_group]
  query_params[:name] = opts[:name] if opts[:name]
  query_params[:metricNamespace] = opts[:metric_namespace] if opts[:metric_namespace]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:compartmentId] = opts[:compartment_id] if opts[:compartment_id]
  query_params[:baselineableMetricId] = opts[:baselineable_metric_id] if opts[:baselineable_metric_id]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_baselineable_metrics') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::BaselineableMetricSummaryCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_configs(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_configs API.

Get a list of configurations in a compartment.

Parameters:

compartment_id (String) —

The ID of the compartment in which data is listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:display_name (String) —

A filter to return only resources that match the entire display name given.
:type (String) —

A filter to return only configuration items for a given config type.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:lifecycle_state (String) —

The current state of the Config.
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for 'timeCreated' is descending. Default order for 'displayName' and 'configType' is ascending. (default to timeCreated) Allowed values are: timeCreated, configType, displayName
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type ConfigCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2622

def list_configs(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_configs.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_configs." if compartment_id.nil?

  if opts[:type] && !OCI::StackMonitoring::Models::Config::CONFIG_TYPE_ENUM.include?(opts[:type])
    raise 'Invalid value for "type", must be one of the values in OCI::StackMonitoring::Models::Config::CONFIG_TYPE_ENUM.'
  end

  if opts[:lifecycle_state] && !OCI::StackMonitoring::Models::Config::LIFECYCLE_STATE_ENUM.include?(opts[:lifecycle_state])
    raise 'Invalid value for "lifecycle_state", must be one of the values in OCI::StackMonitoring::Models::Config::LIFECYCLE_STATE_ENUM.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[timeCreated configType displayName].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timeCreated, configType, displayName.'
  end

  path = '/configs'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:displayName] = opts[:display_name] if opts[:display_name]
  query_params[:type] = opts[:type] if opts[:type]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:lifecycleState] = opts[:lifecycle_state] if opts[:lifecycle_state]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_configs') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::ConfigCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_discovery_job_logs(discovery_job_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_discovery_job_logs API.

API to get all the logs of a Discovery Job.

Allowed values are: timeCreated, logType

Parameters:

discovery_job_id (String) —

The Discovery Job ID
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:log_type (String) —

The log type like INFO, WARNING, ERROR, SUCCESS Allowed values are: INFO, WARNING, ERROR, SUCCESS
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for logType is ascending. (default to timeCreated)
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type DiscoveryJobLogCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2717

def list_discovery_job_logs(discovery_job_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_discovery_job_logs.' if logger

  raise "Missing the required parameter 'discovery_job_id' when calling list_discovery_job_logs." if discovery_job_id.nil?

  if opts[:log_type] && !%w[INFO WARNING ERROR SUCCESS].include?(opts[:log_type])
    raise 'Invalid value for "log_type", must be one of INFO, WARNING, ERROR, SUCCESS.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[timeCreated logType].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timeCreated, logType.'
  end
  raise "Parameter value for 'discovery_job_id' must not be blank" if OCI::Internal::Util.blank_string?(discovery_job_id)

  path = '/discoveryJobs/{discoveryJobId}/logs'.sub('{discoveryJobId}', discovery_job_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:logType] = opts[:log_type] if opts[:log_type]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_discovery_job_logs') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::DiscoveryJobLogCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_discovery_jobs(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_discovery_jobs API.

API to get the details of all Discovery Jobs.

Allowed values are: timeUpdated, resourceName

Parameters:

compartment_id (String) —

The ID of the compartment in which data is listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:name (String) —

A filter to return only discovery jobs that match the entire resource name given.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timeUpdated is descending. Default order for resourceName is ascending. (default to timeUpdated)
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type DiscoveryJobCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2805

def list_discovery_jobs(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_discovery_jobs.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_discovery_jobs." if compartment_id.nil?

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[timeUpdated resourceName].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timeUpdated, resourceName.'
  end

  path = '/discoveryJobs'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:name] = opts[:name] if opts[:name]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_discovery_jobs') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::DiscoveryJobCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_metric_extensions(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_metric_extensions API.

Returns a list of metric extensions

Parameters:

compartment_id (String) —

The ID of the compartment in which data is listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for resources is ascending. (default to TIME_CREATED)
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:resource_type (String) —

A filter to return resources based on resource type.
:name (String) —

A filter to return resources based on name.
:status (String) —

A filter to return resources based on status e.g. Draft or Published
:lifecycle_state (String) —

A filter to return metric extensions based on Lifecycle State
:enabled_on_resource_id (String) —

A filter to return metric extensions based on input resource Id on which metric extension is enabled
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MetricExtensionCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2892

def list_metric_extensions(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_metric_extensions.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_metric_extensions." if compartment_id.nil?

  if opts[:sort_by] && !OCI::StackMonitoring::Models::METRIC_EXTENSION_SORT_BY_ENUM.include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of the values in OCI::StackMonitoring::Models::METRIC_EXTENSION_SORT_BY_ENUM.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:status] && !OCI::StackMonitoring::Models::METRIC_EXTENSION_LIFE_CYCLE_DETAILS_ENUM.include?(opts[:status])
    raise 'Invalid value for "status", must be one of the values in OCI::StackMonitoring::Models::METRIC_EXTENSION_LIFE_CYCLE_DETAILS_ENUM.'
  end

  if opts[:lifecycle_state] && !OCI::StackMonitoring::Models::METRIC_EXTENSION_LIFE_CYCLE_STATES_ENUM.include?(opts[:lifecycle_state])
    raise 'Invalid value for "lifecycle_state", must be one of the values in OCI::StackMonitoring::Models::METRIC_EXTENSION_LIFE_CYCLE_STATES_ENUM.'
  end

  path = '/metricExtensions'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:resourceType] = opts[:resource_type] if opts[:resource_type]
  query_params[:name] = opts[:name] if opts[:name]
  query_params[:status] = opts[:status] if opts[:status]
  query_params[:lifecycleState] = opts[:lifecycle_state] if opts[:lifecycle_state]
  query_params[:enabledOnResourceId] = opts[:enabled_on_resource_id] if opts[:enabled_on_resource_id]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_metric_extensions') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MetricExtensionCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_monitored_resource_tasks(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_monitored_resource_tasks API.

Returns a list of stack monitoring resource tasks in the compartment.

Parameters:

compartment_id (String) —

The OCID of the compartment for which stack monitoring resource tasks should be listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:status (String) —

A filter to return only resources that matches with lifecycleState given.
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for 'timeUpdated' is descending. (default to timeUpdated) Allowed values are: timeUpdated
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResourceTasksCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 2991

def list_monitored_resource_tasks(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_monitored_resource_tasks.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_monitored_resource_tasks." if compartment_id.nil?

  if opts[:status] && !OCI::StackMonitoring::Models::MONITORED_RESOURCE_TASK_LIFECYCLE_STATE_ENUM.include?(opts[:status])
    raise 'Invalid value for "status", must be one of the values in OCI::StackMonitoring::Models::MONITORED_RESOURCE_TASK_LIFECYCLE_STATE_ENUM.'
  end

  if opts[:sort_by] && !%w[timeUpdated].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timeUpdated.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  path = '/monitoredResourceTasks'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:status] = opts[:status] if opts[:status]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_monitored_resource_tasks') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceTasksCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_monitored_resource_types(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_monitored_resource_types API.

Returns list of resource types accessible to the customer. There are two types of resource types - System resource types and User resource types. System resource types are available out of the box in the stack monitoring resource service and are accessible to all the tenant users. User resource types are created in the context of a tenancy and are visible only for the tenancy. By default, both System resource types and User resource types are returned.

Parameters:

compartment_id (String) —

The OCID of the tenancy for which monitored resource types should be listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:name (String) —

A filter to return monitored resource types that match exactly with the resource type name given.
:status (String) —

A filter to return only resources that matches with lifecycleState given.
:is_exclude_system_types (BOOLEAN) —

A filter to exclude system resource types. If set to true, system resource types will be excluded. (default to false)
:metric_namespace (String) —

A filter to return monitored resource types that has the matching namespace.
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for 'timeUpdated' is descending. Default order for 'name' is ascending. (default to timeUpdated) Allowed values are: timeUpdated, name
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:fields (Array<String>) —

Partial response refers to an optimization technique offered by the RESTful web APIs, to return only the information (fields) required by the client. In this mechanism, the client sends the required field names as the query parameters for an API to the server, and the server trims down the default response content by removing the fields that are not required by the client. The parameter controls which fields to return and should be a query string parameter called "fields" of an array type, provide the values as enums, and use collectionFormat.

MonitoredResourceType Id, name and compartment will be added by default.
:exclude_fields (Array<String>) —

Partial response refers to an optimization technique offered by the RESTful web APIs, to return all the information except the fields requested to be excluded (excludeFields) by the client. In this mechanism, the client sends the exclude field names as the query parameters for an API to the server, and the server trims down the default response content by removing the fields that are not required by the client. The parameter controls which fields to exlude and to return and should be a query string parameter called "excludeFields" of an array type, provide the values as enums, and use collectionFormat.

Returns:

(Response) —

A Response object with data of type MonitoredResourceTypesCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3117

def list_monitored_resource_types(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_monitored_resource_types.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_monitored_resource_types." if compartment_id.nil?

  if opts[:status] && !OCI::StackMonitoring::Models::RESOURCE_TYPE_LIFECYCLE_STATE_ENUM.include?(opts[:status])
    raise 'Invalid value for "status", must be one of the values in OCI::StackMonitoring::Models::RESOURCE_TYPE_LIFECYCLE_STATE_ENUM.'
  end

  if opts[:sort_by] && !%w[timeUpdated name].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timeUpdated, name.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  path = '/monitoredResourceTypes'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:name] = opts[:name] if opts[:name]
  query_params[:status] = opts[:status] if opts[:status]
  query_params[:isExcludeSystemTypes] = opts[:is_exclude_system_types] if !opts[:is_exclude_system_types].nil?
  query_params[:metricNamespace] = opts[:metric_namespace] if opts[:metric_namespace]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:fields] = OCI::ApiClient.build_collection_params(opts[:fields], :multi) if opts[:fields] && !opts[:fields].empty?
  query_params[:excludeFields] = OCI::ApiClient.build_collection_params(opts[:exclude_fields], :multi) if opts[:exclude_fields] && !opts[:exclude_fields].empty?

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_monitored_resource_types') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceTypesCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_monitored_resources(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_monitored_resources API.

Returns a list of monitored resources.

Parameters:

compartment_id (String) —

The ID of the compartment in which data is listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:name (String) —

A filter to return resources that match exact resource name.
:work_request_id (String) —

A filter to return resources which were impacted as part of this work request identifier.
:status (String) —

A filter to return only resources with matching lifecycleState.
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for resources is ascending. (default to TIME_CREATED)
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResourceCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3211

def list_monitored_resources(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_monitored_resources.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_monitored_resources." if compartment_id.nil?

  if opts[:status] && !OCI::StackMonitoring::Models::RESOURCE_LIFECYCLE_STATE_ENUM.include?(opts[:status])
    raise 'Invalid value for "status", must be one of the values in OCI::StackMonitoring::Models::RESOURCE_LIFECYCLE_STATE_ENUM.'
  end

  if opts[:sort_by] && !OCI::StackMonitoring::Models::MONITORED_RESOURCE_SORT_BY_ENUM.include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of the values in OCI::StackMonitoring::Models::MONITORED_RESOURCE_SORT_BY_ENUM.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  path = '/monitoredResources'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:name] = opts[:name] if opts[:name]
  query_params[:workRequestId] = opts[:work_request_id] if opts[:work_request_id]
  query_params[:status] = opts[:status] if opts[:status]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_monitored_resources') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_process_sets(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_process_sets API.

API to get the details of all Process Sets. Allowed values are: timeUpdated, name

Parameters:

compartment_id (String) —

The ID of the compartment in which data is listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timeUpdated is descending. Default order for name is ascending. (default to timeUpdated)
:display_name (String) —

A filter to return only resources that match the entire display name given.

Returns:

(Response) —

A Response object with data of type ProcessSetCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3300

def list_process_sets(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_process_sets.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_process_sets." if compartment_id.nil?

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[timeUpdated name].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timeUpdated, name.'
  end

  path = '/processSets'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:displayName] = opts[:display_name] if opts[:display_name]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_process_sets') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::ProcessSetCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_work_request_errors(work_request_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_work_request_errors API.

Return a (paginated) list of errors for a given work request.

Allowed values are: timestamp

Parameters:

work_request_id (String) —

The OCID of the work request.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timestamp is descending. If no value is specified timestamp is default. (default to timestamp)

Returns:

(Response) —

A Response object with data of type WorkRequestErrorCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3383

def list_work_request_errors(work_request_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_work_request_errors.' if logger

  raise "Missing the required parameter 'work_request_id' when calling list_work_request_errors." if work_request_id.nil?

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[timestamp].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timestamp.'
  end
  raise "Parameter value for 'work_request_id' must not be blank" if OCI::Internal::Util.blank_string?(work_request_id)

  path = '/workRequests/{workRequestId}/errors'.sub('{workRequestId}', work_request_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_work_request_errors') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::WorkRequestErrorCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_work_request_logs(work_request_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_work_request_logs API.

Return a (paginated) list of logs for a given work request.

Allowed values are: timestamp

Parameters:

work_request_id (String) —

The OCID of the work request.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timestamp is descending. If no value is specified timestamp is default. (default to timestamp)

Returns:

(Response) —

A Response object with data of type WorkRequestLogEntryCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3465

def list_work_request_logs(work_request_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_work_request_logs.' if logger

  raise "Missing the required parameter 'work_request_id' when calling list_work_request_logs." if work_request_id.nil?

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[timestamp].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timestamp.'
  end
  raise "Parameter value for 'work_request_id' must not be blank" if OCI::Internal::Util.blank_string?(work_request_id)

  path = '/workRequests/{workRequestId}/logs'.sub('{workRequestId}', work_request_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_work_request_logs') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::WorkRequestLogEntryCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_work_requests(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use list_work_requests API.

Lists the work requests in a compartment.

Allowed values are: timeAccepted

Parameters:

compartment_id (String) —

The ID of the compartment in which data is listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:work_request_id (String) —

The ID of the asynchronous work request.
:status (String) —

A filter to return only resources their lifecycleState matches the given OperationStatus.
:resource_id (String) —

The ID of the resource affected by the work request.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:sort_by (String) —

The field to sort by. Only one sort order may be provided. Default order for timeAccepted is descending. If no value is specified timeAccepted is default. (default to timeAccepted)

Returns:

(Response) —

A Response object with data of type WorkRequestSummaryCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3550

def list_work_requests(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#list_work_requests.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_work_requests." if compartment_id.nil?

  if opts[:status] && !OCI::StackMonitoring::Models::OPERATION_STATUS_ENUM.include?(opts[:status])
    raise 'Invalid value for "status", must be one of the values in OCI::StackMonitoring::Models::OPERATION_STATUS_ENUM.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  if opts[:sort_by] && !%w[timeAccepted].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of timeAccepted.'
  end

  path = '/workRequests'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:workRequestId] = opts[:work_request_id] if opts[:work_request_id]
  query_params[:status] = opts[:status] if opts[:status]
  query_params[:resourceId] = opts[:resource_id] if opts[:resource_id]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#list_work_requests') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::WorkRequestSummaryCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#logger ⇒ `Logger`

Returns The logger for this client. May be nil.

Returns:

(Logger) —

The logger for this client. May be nil.



94
95
96

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 94

def logger
  @api_client.config.logger
end

#manage_license(monitored_resource_id, manage_license_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use manage_license API.

Each resource is assigned a license based on which features are enabled for it. User is charged differently based on license. Specify the license type to be updated for the parent resource in the topology. The license type value is propagated to the member resources as well. Member resource is a resource which has "contains" association with the resource.

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
manage_license_details (OCI::StackMonitoring::Models::ManageLicenseDetails) —

New license information.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3643

def manage_license(monitored_resource_id, manage_license_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#manage_license.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling manage_license." if monitored_resource_id.nil?
  raise "Missing the required parameter 'manage_license_details' when calling manage_license." if manage_license_details.nil?
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}/actions/manageLicense'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(manage_license_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#manage_license') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#publish_metric_extension(metric_extension_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use publish_metric_extension API.

Publish the Metric Extension identified by the id

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type MetricExtension

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3714

def publish_metric_extension(metric_extension_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#publish_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling publish_metric_extension." if metric_extension_id.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}/actions/publish'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#publish_metric_extension') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MetricExtension'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#request_monitored_resources_summarized_count(compartment_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use request_monitored_resources_summarized_count API.

Gets resource count based on the aggregation criteria specified using "groupBy" parameter.

Allowed values are: resourceType, license, parentResourceId Allowed values are: count

Parameters:

compartment_id (String) —

The ID of the compartment in which data is listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:group_by (String) —

The field to group by. Default group by is 'resourceType'. (default to resourceType)
:license (String) —

Filter to return resource counts that match with the given licence edition.
:resource_type (String) —

A filter to return resource counts that match exact resource type.
:sort_by (String) —

If this query parameter is specified, the result is sorted by this query parameter value. (default to count)
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResourcesCountAggregationCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3793

def request_monitored_resources_summarized_count(compartment_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#request_monitored_resources_summarized_count.' if logger

  raise "Missing the required parameter 'compartment_id' when calling request_monitored_resources_summarized_count." if compartment_id.nil?

  if opts[:group_by] && !%w[resourceType license parentResourceId].include?(opts[:group_by])
    raise 'Invalid value for "group_by", must be one of resourceType, license, parentResourceId.'
  end

  if opts[:license] && !OCI::StackMonitoring::Models::LICENSE_TYPE_ENUM.include?(opts[:license])
    raise 'Invalid value for "license", must be one of the values in OCI::StackMonitoring::Models::LICENSE_TYPE_ENUM.'
  end

  if opts[:sort_by] && !%w[count].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of count.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end

  path = '/monitoredResources/actions/summarizeCount'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:groupBy] = opts[:group_by] if opts[:group_by]
  query_params[:license] = opts[:license] if opts[:license]
  query_params[:resourceType] = opts[:resource_type] if opts[:resource_type]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#request_monitored_resources_summarized_count') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourcesCountAggregationCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#search_associated_resources(search_associated_resources_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use search_associated_resources API.

List all associated resources recursively up-to a specified level, for the monitored resources of type specified.

Parameters:

search_associated_resources_details (OCI::StackMonitoring::Models::SearchAssociatedResourcesDetails) —

Search Criteria for the listing the monitored resources for given type and compartmentId.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:fields (Array<String>) —

Partial response refers to an optimization technique offered by the RESTful web APIs, to return only the information (fields) required by the client. In this mechanism, the client sends the required field names as the query parameters for an API to the server, and the server trims down the default response content by removing the fields that are not required by the client. The parameter controls which fields to return and should be a query string parameter called "fields" of an array type, provide the values as enums, and use collectionFormat.
:exclude_fields (Array<String>) —

Partial response refers to an optimization technique offered by the RESTful web APIs, to return all the information except the fields requested to be excluded (excludeFields) by the client. In this mechanism, the client sends the exclude field names as the query parameters for an API to the server, and the server trims down the default response content by removing the fields that are not required by the client. The parameter controls which fields to exlude and to return and should be a query string parameter called "excludeFields" of an array type, provide the values as enums, and use collectionFormat.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.

Returns:

(Response) —

A Response object with data of type AssociatedResourcesCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 3916

def search_associated_resources(search_associated_resources_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#search_associated_resources.' if logger

  raise "Missing the required parameter 'search_associated_resources_details' when calling search_associated_resources." if search_associated_resources_details.nil?

  path = '/monitoredResources/actions/searchAssociatedResources'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:fields] = OCI::ApiClient.build_collection_params(opts[:fields], :multi) if opts[:fields] && !opts[:fields].empty?
  query_params[:excludeFields] = OCI::ApiClient.build_collection_params(opts[:exclude_fields], :multi) if opts[:exclude_fields] && !opts[:exclude_fields].empty?
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(search_associated_resources_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#search_associated_resources') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::AssociatedResourcesCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#search_monitored_resource_associations(search_monitored_resource_associations_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use search_monitored_resource_associations API.

Search associations in the given compartment based on the search criteria.

Parameters:

search_monitored_resource_associations_details (OCI::StackMonitoring::Models::SearchMonitoredResourceAssociationsDetails) —

Search criteria for listing monitored resource associations.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type MonitoredResourceAssociationsCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4000

def search_monitored_resource_associations(search_monitored_resource_associations_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#search_monitored_resource_associations.' if logger

  raise "Missing the required parameter 'search_monitored_resource_associations_details' when calling search_monitored_resource_associations." if search_monitored_resource_associations_details.nil?

  path = '/monitoredResources/actions/searchAssociations'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(search_monitored_resource_associations_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#search_monitored_resource_associations') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceAssociationsCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#search_monitored_resource_members(monitored_resource_id, search_monitored_resource_members_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use search_monitored_resource_members API.

List the member resources for the given monitored resource identifier OCID.

Allowed values are: resourceName, resourceType, sourceResourceType

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
search_monitored_resource_members_details (OCI::StackMonitoring::Models::SearchMonitoredResourceMembersDetails) —

Search criteria for listing member monitored resources.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:sort_by (String) —

If this query parameter is specified, the result is sorted by this query parameter value. (default to resourceName)
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). (default to ASC)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type MonitoredResourceMembersCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4088

def search_monitored_resource_members(monitored_resource_id, search_monitored_resource_members_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#search_monitored_resource_members.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling search_monitored_resource_members." if monitored_resource_id.nil?
  raise "Missing the required parameter 'search_monitored_resource_members_details' when calling search_monitored_resource_members." if search_monitored_resource_members_details.nil?

  if opts[:sort_by] && !%w[resourceName resourceType sourceResourceType].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of resourceName, resourceType, sourceResourceType.'
  end

  if opts[:sort_order] && !OCI::StackMonitoring::Models::SORT_ORDER_ENUM.include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of the values in OCI::StackMonitoring::Models::SORT_ORDER_ENUM.'
  end
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}/actions/listMembers'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:limit] = opts[:limit] if opts[:limit]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(search_monitored_resource_members_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#search_monitored_resource_members') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceMembersCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#search_monitored_resources(search_monitored_resources_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use search_monitored_resources API.

Gets a list of all monitored resources in a compartment for the given search criteria.

Parameters:

search_monitored_resources_details (OCI::StackMonitoring::Models::SearchMonitoredResourcesDetails) —

Search Criteria for listing monitored resources.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:limit (Integer) —

For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see List Pagination. (default to 10)
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see List Pagination.
:fields (Array<String>) —

Partial response refers to an optimization technique offered by the RESTful web APIs, to return only the information (fields) required by the client. In this mechanism, the client sends the required field names as the query parameters for an API to the server, and the server trims down the default response content by removing the fields that are not required by the client. The parameter controls which fields to return and should be a query string parameter called "fields" of an array type, provide the values as enums, and use collectionFormat.
:exclude_fields (Array<String>) —

Partial response refers to an optimization technique offered by the RESTful web APIs, to return all the information except the fields requested to be excluded (excludeFields) by the client. In this mechanism, the client sends the exclude field names as the query parameters for an API to the server, and the server trims down the default response content by removing the fields that are not required by the client. The parameter controls which fields to exlude and to return and should be a query string parameter called "excludeFields" of an array type, provide the values as enums, and use collectionFormat.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type MonitoredResourceCollection

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4204

def search_monitored_resources(search_monitored_resources_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#search_monitored_resources.' if logger

  raise "Missing the required parameter 'search_monitored_resources_details' when calling search_monitored_resources." if search_monitored_resources_details.nil?

  path = '/monitoredResources/actions/search'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:fields] = OCI::ApiClient.build_collection_params(opts[:fields], :multi) if opts[:fields] && !opts[:fields].empty?
  query_params[:excludeFields] = OCI::ApiClient.build_collection_params(opts[:exclude_fields], :multi) if opts[:exclude_fields] && !opts[:exclude_fields].empty?

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(search_monitored_resources_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#search_monitored_resources') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceCollection'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#test_metric_extension(metric_extension_id, test_metric_extension_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use test_metric_extension API.

Performs test of Metric Extension on a specific resource Id

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
test_metric_extension_details (OCI::StackMonitoring::Models::TestMetricExtensionDetails) —

It contains OCID of resource.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.

Returns:

(Response) —

A Response object with data of type TestMetricExtensionData

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4279

def test_metric_extension(metric_extension_id, test_metric_extension_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#test_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling test_metric_extension." if metric_extension_id.nil?
  raise "Missing the required parameter 'test_metric_extension_details' when calling test_metric_extension." if test_metric_extension_details.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}/actions/test'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(test_metric_extension_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#test_metric_extension') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::TestMetricExtensionData'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_and_propagate_tags(monitored_resource_id, update_and_propagate_tags_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_and_propagate_tags API.

Provided tags will be added or updated in the existing list of tags for the affected resources. Resources to be updated are identified based on association types specified. If association types not specified, then tags will be updated only for the resource identified by the given monitored resource identifier OCID.

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
update_and_propagate_tags_details (OCI::StackMonitoring::Models::UpdateAndPropagateTagsDetails) —

The tags to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations. For example, if a resource has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4356

def update_and_propagate_tags(monitored_resource_id, update_and_propagate_tags_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_and_propagate_tags.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling update_and_propagate_tags." if monitored_resource_id.nil?
  raise "Missing the required parameter 'update_and_propagate_tags_details' when calling update_and_propagate_tags." if update_and_propagate_tags_details.nil?
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}/actions/updateAndPropagateTags'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_and_propagate_tags_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_and_propagate_tags') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_baselineable_metric(update_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_baselineable_metric API.

Updates the Baseline-able metric for the given id

Parameters:

update_baselineable_metric_details (OCI::StackMonitoring::Models::UpdateBaselineableMetricDetails) —

Baseline metric
baselineable_metric_id (String) —

Identifier for the metric
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type BaselineableMetric

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4422

def update_baselineable_metric(update_baselineable_metric_details, baselineable_metric_id, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_baselineable_metric.' if logger

  raise "Missing the required parameter 'update_baselineable_metric_details' when calling update_baselineable_metric." if update_baselineable_metric_details.nil?
  raise "Missing the required parameter 'baselineable_metric_id' when calling update_baselineable_metric." if baselineable_metric_id.nil?
  raise "Parameter value for 'baselineable_metric_id' must not be blank" if OCI::Internal::Util.blank_string?(baselineable_metric_id)

  path = '/baselineableMetrics/{baselineableMetricId}'.sub('{baselineableMetricId}', baselineable_metric_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_baselineable_metric_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_baselineable_metric') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::BaselineableMetric'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_config(config_id, update_config_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_config API.

Updates the configuration identified by the id given.

Parameters:

config_id (String) —

Unique Config identifier.
update_config_details (OCI::StackMonitoring::Models::UpdateConfigDetails) —

The details of the configuration to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type Config

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4487

def update_config(config_id, update_config_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_config.' if logger

  raise "Missing the required parameter 'config_id' when calling update_config." if config_id.nil?
  raise "Missing the required parameter 'update_config_details' when calling update_config." if update_config_details.nil?
  raise "Parameter value for 'config_id' must not be blank" if OCI::Internal::Util.blank_string?(config_id)

  path = '/configs/{configId}'.sub('{configId}', config_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_config_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_config') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::Config'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_metric_extension(metric_extension_id, update_metric_extension_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_metric_extension API.

Updates the Metric Extension

Parameters:

metric_extension_id (String) —

The OCID of the metric extension resource.
update_metric_extension_details (OCI::StackMonitoring::Models::UpdateMetricExtensionDetails) —

The information to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MetricExtension

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4552

def update_metric_extension(metric_extension_id, update_metric_extension_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_metric_extension.' if logger

  raise "Missing the required parameter 'metric_extension_id' when calling update_metric_extension." if metric_extension_id.nil?
  raise "Missing the required parameter 'update_metric_extension_details' when calling update_metric_extension." if update_metric_extension_details.nil?
  raise "Parameter value for 'metric_extension_id' must not be blank" if OCI::Internal::Util.blank_string?(metric_extension_id)

  path = '/metricExtensions/{metricExtensionId}'.sub('{metricExtensionId}', metric_extension_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_metric_extension_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_metric_extension') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MetricExtension'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_monitored_resource(monitored_resource_id, update_monitored_resource_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_monitored_resource API.

Update monitored resource by the given identifier OCID. Note that "properties" object, if specified, will entirely replace the existing object, as part this operation.

Parameters:

monitored_resource_id (String) —

The OCID of monitored resource.
update_monitored_resource_details (OCI::StackMonitoring::Models::UpdateMonitoredResourceDetails) —

The information to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4620

def update_monitored_resource(monitored_resource_id, update_monitored_resource_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_monitored_resource.' if logger

  raise "Missing the required parameter 'monitored_resource_id' when calling update_monitored_resource." if monitored_resource_id.nil?
  raise "Missing the required parameter 'update_monitored_resource_details' when calling update_monitored_resource." if update_monitored_resource_details.nil?
  raise "Parameter value for 'monitored_resource_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_id)

  path = '/monitoredResources/{monitoredResourceId}'.sub('{monitoredResourceId}', monitored_resource_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_monitored_resource_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_monitored_resource') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_monitored_resource_task(monitored_resource_task_id, update_monitored_resource_task_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_monitored_resource_task API.

Update stack monitoring resource task by the given identifier OCID.

Parameters:

monitored_resource_task_id (String) —

The OCID of stack monitoring resource task.
update_monitored_resource_task_details (OCI::StackMonitoring::Models::UpdateMonitoredResourceTaskDetails) —

The information to be updated.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResourceTask

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4685

def update_monitored_resource_task(monitored_resource_task_id, update_monitored_resource_task_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_monitored_resource_task.' if logger

  raise "Missing the required parameter 'monitored_resource_task_id' when calling update_monitored_resource_task." if monitored_resource_task_id.nil?
  raise "Missing the required parameter 'update_monitored_resource_task_details' when calling update_monitored_resource_task." if update_monitored_resource_task_details.nil?
  raise "Parameter value for 'monitored_resource_task_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_task_id)

  path = '/monitoredResourceTasks/{monitoredResourceTaskId}'.sub('{monitoredResourceTaskId}', monitored_resource_task_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_monitored_resource_task_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_monitored_resource_task') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceTask'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_monitored_resource_type(monitored_resource_type_id, update_monitored_resource_type_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_monitored_resource_type API.

Update the Monitored Resource Type identified by the identifier OCID.

Parameters:

monitored_resource_type_id (String) —

The OCID of monitored resource type.
update_monitored_resource_type_details (OCI::StackMonitoring::Models::UpdateMonitoredResourceTypeDetails) —

The information to be updated for the given resource type id.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type MonitoredResourceType

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4751

def update_monitored_resource_type(monitored_resource_type_id, update_monitored_resource_type_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_monitored_resource_type.' if logger

  raise "Missing the required parameter 'monitored_resource_type_id' when calling update_monitored_resource_type." if monitored_resource_type_id.nil?
  raise "Missing the required parameter 'update_monitored_resource_type_details' when calling update_monitored_resource_type." if update_monitored_resource_type_details.nil?
  raise "Parameter value for 'monitored_resource_type_id' must not be blank" if OCI::Internal::Util.blank_string?(monitored_resource_type_id)

  path = '/monitoredResourceTypes/{monitoredResourceTypeId}'.sub('{monitoredResourceTypeId}', monitored_resource_type_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_monitored_resource_type_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_monitored_resource_type') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::MonitoredResourceType'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_process_set(process_set_id, update_process_set_details, opts = {}) ⇒ `Response`

Note:

Click here to see an example of how to use update_process_set API.

API to update a Process Set identified by a given ocid.

Parameters:

process_set_id (String) —

The Process Set ID
update_process_set_details (OCI::StackMonitoring::Models::UpdateProcessSetDetails) —

The updated Process Set details.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:if_match (String) —

For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.

Returns:

(Response) —

A Response object with data of type ProcessSet

# File 'lib/oci/stack_monitoring/stack_monitoring_client.rb', line 4816

def update_process_set(process_set_id, update_process_set_details, opts = {})
  logger.debug 'Calling operation StackMonitoringClient#update_process_set.' if logger

  raise "Missing the required parameter 'process_set_id' when calling update_process_set." if process_set_id.nil?
  raise "Missing the required parameter 'update_process_set_details' when calling update_process_set." if update_process_set_details.nil?
  raise "Parameter value for 'process_set_id' must not be blank" if OCI::Internal::Util.blank_string?(process_set_id)

  path = '/processSets/{processSetId}'.sub('{processSetId}', process_set_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_process_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'StackMonitoringClient#update_process_set') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::StackMonitoring::Models::ProcessSet'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

Class: OCI::StackMonitoring::StackMonitoringClient

Overview

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ StackMonitoringClient

Instance Attribute Details

#api_client ⇒ OCI::ApiClient (readonly)

#endpoint ⇒ String (readonly)

#region ⇒ String

#retry_config ⇒ OCI::Retry::RetryConfig (readonly)

Instance Method Details

#associate_monitored_resources(associate_monitored_resources_details, opts = {}) ⇒ Response

#change_config_compartment(config_id, change_config_compartment_details, opts = {}) ⇒ Response

#change_metric_extension_compartment(metric_extension_id, change_metric_extension_compartment_details, opts = {}) ⇒ Response

#change_monitored_resource_compartment(monitored_resource_id, change_monitored_resource_compartment_details, opts = {}) ⇒ Response

#change_monitored_resource_task_compartment(monitored_resource_task_id, change_monitored_resource_task_compartment_details, opts = {}) ⇒ Response

#change_process_set_compartment(process_set_id, change_process_set_compartment_details, opts = {}) ⇒ Response

#create_baselineable_metric(create_baselineable_metric_details, opts = {}) ⇒ Response

#create_config(create_config_details, opts = {}) ⇒ Response

#create_discovery_job(create_discovery_job_details, opts = {}) ⇒ Response

#create_metric_extension(create_metric_extension_details, opts = {}) ⇒ Response

#create_monitored_resource(create_monitored_resource_details, opts = {}) ⇒ Response

#create_monitored_resource_task(create_monitored_resource_task_details, opts = {}) ⇒ Response

#create_monitored_resource_type(create_monitored_resource_type_details, opts = {}) ⇒ Response

#create_process_set(create_process_set_details, opts = {}) ⇒ Response

#delete_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ Response

#delete_config(config_id, opts = {}) ⇒ Response

#delete_discovery_job(discovery_job_id, opts = {}) ⇒ Response

#delete_metric_extension(metric_extension_id, opts = {}) ⇒ Response

#delete_monitored_resource(monitored_resource_id, opts = {}) ⇒ Response

#delete_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ Response

#delete_process_set(process_set_id, opts = {}) ⇒ Response

#disable_external_database(monitored_resource_id, opts = {}) ⇒ Response

#disable_metric_extension(metric_extension_id, disable_metric_extension_details, opts = {}) ⇒ Response

#disassociate_monitored_resources(disassociate_monitored_resources_details, opts = {}) ⇒ Response

#enable_metric_extension(metric_extension_id, enable_metric_extension_details, opts = {}) ⇒ Response

#evaluate_baselineable_metric(evaluate_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ Response

#export_metric_extension(metric_extension_id, opts = {}, &block) ⇒ Response

#get_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ Response

#get_config(config_id, opts = {}) ⇒ Response

#get_discovery_job(discovery_job_id, opts = {}) ⇒ Response

#get_metric_extension(metric_extension_id, opts = {}) ⇒ Response

#get_monitored_resource(monitored_resource_id, opts = {}) ⇒ Response

#get_monitored_resource_task(monitored_resource_task_id, opts = {}) ⇒ Response

#get_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ Response

#get_process_set(process_set_id, opts = {}) ⇒ Response

#get_work_request(work_request_id, opts = {}) ⇒ Response

#list_baselineable_metrics(opts = {}) ⇒ Response

#list_configs(compartment_id, opts = {}) ⇒ Response

#list_discovery_job_logs(discovery_job_id, opts = {}) ⇒ Response

#list_discovery_jobs(compartment_id, opts = {}) ⇒ Response

#list_metric_extensions(compartment_id, opts = {}) ⇒ Response

#list_monitored_resource_tasks(compartment_id, opts = {}) ⇒ Response

#list_monitored_resource_types(compartment_id, opts = {}) ⇒ Response

#list_monitored_resources(compartment_id, opts = {}) ⇒ Response

#list_process_sets(compartment_id, opts = {}) ⇒ Response

#list_work_request_errors(work_request_id, opts = {}) ⇒ Response

#list_work_request_logs(work_request_id, opts = {}) ⇒ Response

#list_work_requests(compartment_id, opts = {}) ⇒ Response

#logger ⇒ Logger

#manage_license(monitored_resource_id, manage_license_details, opts = {}) ⇒ Response

#publish_metric_extension(metric_extension_id, opts = {}) ⇒ Response

#request_monitored_resources_summarized_count(compartment_id, opts = {}) ⇒ Response

#search_associated_resources(search_associated_resources_details, opts = {}) ⇒ Response

#search_monitored_resource_associations(search_monitored_resource_associations_details, opts = {}) ⇒ Response

#search_monitored_resource_members(monitored_resource_id, search_monitored_resource_members_details, opts = {}) ⇒ Response

#search_monitored_resources(search_monitored_resources_details, opts = {}) ⇒ Response

#test_metric_extension(metric_extension_id, test_metric_extension_details, opts = {}) ⇒ Response

#update_and_propagate_tags(monitored_resource_id, update_and_propagate_tags_details, opts = {}) ⇒ Response

#update_baselineable_metric(update_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ Response

#update_config(config_id, update_config_details, opts = {}) ⇒ Response

#update_metric_extension(metric_extension_id, update_metric_extension_details, opts = {}) ⇒ Response

#update_monitored_resource(monitored_resource_id, update_monitored_resource_details, opts = {}) ⇒ Response

#update_monitored_resource_task(monitored_resource_task_id, update_monitored_resource_task_details, opts = {}) ⇒ Response

#update_monitored_resource_type(monitored_resource_type_id, update_monitored_resource_type_details, opts = {}) ⇒ Response

#update_process_set(process_set_id, update_process_set_details, opts = {}) ⇒ Response

#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ `StackMonitoringClient`

#api_client ⇒ `OCI::ApiClient` (readonly)

#endpoint ⇒ `String` (readonly)

#region ⇒ `String`

#retry_config ⇒ `OCI::Retry::RetryConfig` (readonly)

#associate_monitored_resources(associate_monitored_resources_details, opts = {}) ⇒ `Response`

#change_config_compartment(config_id, change_config_compartment_details, opts = {}) ⇒ `Response`

#change_metric_extension_compartment(metric_extension_id, change_metric_extension_compartment_details, opts = {}) ⇒ `Response`

#change_monitored_resource_compartment(monitored_resource_id, change_monitored_resource_compartment_details, opts = {}) ⇒ `Response`

#change_monitored_resource_task_compartment(monitored_resource_task_id, change_monitored_resource_task_compartment_details, opts = {}) ⇒ `Response`

#change_process_set_compartment(process_set_id, change_process_set_compartment_details, opts = {}) ⇒ `Response`

#create_baselineable_metric(create_baselineable_metric_details, opts = {}) ⇒ `Response`

#create_config(create_config_details, opts = {}) ⇒ `Response`

#create_discovery_job(create_discovery_job_details, opts = {}) ⇒ `Response`

#create_metric_extension(create_metric_extension_details, opts = {}) ⇒ `Response`

#create_monitored_resource(create_monitored_resource_details, opts = {}) ⇒ `Response`

#create_monitored_resource_task(create_monitored_resource_task_details, opts = {}) ⇒ `Response`

#create_monitored_resource_type(create_monitored_resource_type_details, opts = {}) ⇒ `Response`

#create_process_set(create_process_set_details, opts = {}) ⇒ `Response`

#delete_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ `Response`

#delete_config(config_id, opts = {}) ⇒ `Response`

#delete_discovery_job(discovery_job_id, opts = {}) ⇒ `Response`

#delete_metric_extension(metric_extension_id, opts = {}) ⇒ `Response`

#delete_monitored_resource(monitored_resource_id, opts = {}) ⇒ `Response`

#delete_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ `Response`

#delete_process_set(process_set_id, opts = {}) ⇒ `Response`

#disable_external_database(monitored_resource_id, opts = {}) ⇒ `Response`

#disable_metric_extension(metric_extension_id, disable_metric_extension_details, opts = {}) ⇒ `Response`

#disassociate_monitored_resources(disassociate_monitored_resources_details, opts = {}) ⇒ `Response`

#enable_metric_extension(metric_extension_id, enable_metric_extension_details, opts = {}) ⇒ `Response`

#evaluate_baselineable_metric(evaluate_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ `Response`

#export_metric_extension(metric_extension_id, opts = {}, &block) ⇒ `Response`

#get_baselineable_metric(baselineable_metric_id, opts = {}) ⇒ `Response`

#get_config(config_id, opts = {}) ⇒ `Response`

#get_discovery_job(discovery_job_id, opts = {}) ⇒ `Response`

#get_metric_extension(metric_extension_id, opts = {}) ⇒ `Response`

#get_monitored_resource(monitored_resource_id, opts = {}) ⇒ `Response`

#get_monitored_resource_task(monitored_resource_task_id, opts = {}) ⇒ `Response`

#get_monitored_resource_type(monitored_resource_type_id, opts = {}) ⇒ `Response`

#get_process_set(process_set_id, opts = {}) ⇒ `Response`

#get_work_request(work_request_id, opts = {}) ⇒ `Response`

#list_baselineable_metrics(opts = {}) ⇒ `Response`

#list_configs(compartment_id, opts = {}) ⇒ `Response`

#list_discovery_job_logs(discovery_job_id, opts = {}) ⇒ `Response`

#list_discovery_jobs(compartment_id, opts = {}) ⇒ `Response`

#list_metric_extensions(compartment_id, opts = {}) ⇒ `Response`

#list_monitored_resource_tasks(compartment_id, opts = {}) ⇒ `Response`

#list_monitored_resource_types(compartment_id, opts = {}) ⇒ `Response`

#list_monitored_resources(compartment_id, opts = {}) ⇒ `Response`

#list_process_sets(compartment_id, opts = {}) ⇒ `Response`

#list_work_request_errors(work_request_id, opts = {}) ⇒ `Response`

#list_work_request_logs(work_request_id, opts = {}) ⇒ `Response`

#list_work_requests(compartment_id, opts = {}) ⇒ `Response`

#logger ⇒ `Logger`

#manage_license(monitored_resource_id, manage_license_details, opts = {}) ⇒ `Response`

#publish_metric_extension(metric_extension_id, opts = {}) ⇒ `Response`

#request_monitored_resources_summarized_count(compartment_id, opts = {}) ⇒ `Response`

#search_associated_resources(search_associated_resources_details, opts = {}) ⇒ `Response`

#search_monitored_resource_associations(search_monitored_resource_associations_details, opts = {}) ⇒ `Response`

#search_monitored_resource_members(monitored_resource_id, search_monitored_resource_members_details, opts = {}) ⇒ `Response`

#search_monitored_resources(search_monitored_resources_details, opts = {}) ⇒ `Response`

#test_metric_extension(metric_extension_id, test_metric_extension_details, opts = {}) ⇒ `Response`

#update_and_propagate_tags(monitored_resource_id, update_and_propagate_tags_details, opts = {}) ⇒ `Response`

#update_baselineable_metric(update_baselineable_metric_details, baselineable_metric_id, opts = {}) ⇒ `Response`

#update_config(config_id, update_config_details, opts = {}) ⇒ `Response`

#update_metric_extension(metric_extension_id, update_metric_extension_details, opts = {}) ⇒ `Response`

#update_monitored_resource(monitored_resource_id, update_monitored_resource_details, opts = {}) ⇒ `Response`

#update_monitored_resource_task(monitored_resource_task_id, update_monitored_resource_task_details, opts = {}) ⇒ `Response`

#update_monitored_resource_type(monitored_resource_type_id, update_monitored_resource_type_details, opts = {}) ⇒ `Response`

#update_process_set(process_set_id, update_process_set_details, opts = {}) ⇒ `Response`