dogapi 1.37.1 → 1.38.0

data/lib/dogapi/v1.rb

@@ -17,3 +17,7 @@ require 'dogapi/v1/user'
 require 'dogapi/v1/hosts'
 require 'dogapi/v1/integration'
 require 'dogapi/v1/usage'
+require 'dogapi/v1/aws_integration'
+require 'dogapi/v1/aws_logs'
+require 'dogapi/v1/azure_integration'
+require 'dogapi/v1/gcp_integration'

data/lib/dogapi/v1/aws_integration.rb

@@ -0,0 +1,113 @@
+require 'dogapi'
+
+module Dogapi
+  class V1 # for namespacing
+
+    # AwsIntegrationService for user interaction with AWS configs.
+    class AwsIntegrationService < Dogapi::APIService
+
+      API_VERSION = 'v1'
+
+      # Retrieve AWS integration information
+      def aws_integration_list
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/integration/aws", nil, nil, false)
+      end
+
+      # Create an AWS integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :account_id => '<AWS_ACCOUNT>',
+      #   :host_tags => ['api:example'],
+      #   :role_name => '<AWS_ROLE_NAME>'
+      # }
+      #
+      # Access Key/Secret Access Key based accounts (GovCloud and China only)
+      #
+      # config = {
+      #   :access_key_id => '<AWS_ACCESS_KEY_ID>',
+      #   :host_tags => ['api:example'],
+      #   :secret_access_key => '<AWS_SECRET_ACCESS_KEY>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.aws_integration_create(config)
+      def aws_integration_create(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/aws", nil, config, true)
+      end
+
+      # Delete an integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :account_id => '<AWS_ACCOUNT>',
+      #   :role_name => '<AWS_ROLE_NAME>'
+      # }
+      # Access Key/Secret Access Key based accounts (GovCloud and China only)
+      #
+      # config = {
+      #   :access_key_id => '<AWS_ACCESS_KEY_ID>',
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.aws_integration_delete(config)
+      def aws_integration_delete(config)
+        request(Net::HTTP::Delete, "/api/#{API_VERSION}/integration/aws", nil, config, true)
+      end
+
+      # List available AWS namespaces
+      def aws_integration_list_namespaces
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/integration/aws/available_namespace_rules", nil, nil, false)
+      end
+
+      # Generate new AWS external ID for a specific integrated account
+      # :config => Hash: integration config.
+      # config = {
+      #   :account_id => '<AWS_ACCOUNT>',
+      #   :role_name => '<AWS_ROLE_NAME>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.aws_integration_generate_external_id(config)
+      def aws_integration_generate_external_id(config)
+        request(Net::HTTP::Put, "/api/#{API_VERSION}/integration/aws/generate_new_external_id", nil, config, true)
+      end
+
+      # Update integrated AWS account.
+      # :config => Hash: integration config.
+      # config = {
+      #   "account_id": '<EXISTING_AWS_ACCOUNT>',
+      #   "role_name": '<EXISTING_AWS_ROLE_NAME>'
+      # }
+      #
+      # new_config = {
+      #   "account_id": '<NEW_AWS_ACCOUNT>',
+      #   "host_tags": ['tag:example1,tag:example2'],
+      #   "filter_tags": ['datadog:true']
+      # }
+      #
+      # Access Key/Secret Access Key based accounts (GovCloud and China only)
+      #
+      # config = {
+      #   "access_key_id": '<EXISTING_ACCESS_KEY_ID>',
+      #   "secret_access_key": '<EXISTING_SECRET_ACCESS_KEY>'
+      # }
+      #
+      # new_config = {
+      #   "access_key_id": '<NEW_ACCESS_KEY_ID>',
+      #   "host_tags": ['new:tags'],
+      #   "filter_tags": ['datadog:true']
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+
+      # puts dog.aws_integration_update(config, new_config)
+      def aws_integration_update(config, new_config)
+        request(Net::HTTP::Put, "/api/#{API_VERSION}/integration/aws", config, new_config, true)
+      end
+
+    end
+
+  end
+end

data/lib/dogapi/v1/aws_logs.rb

@@ -0,0 +1,103 @@
+require 'dogapi'
+
+module Dogapi
+  class V1 # for namespacing
+
+    # AwsLogsService for user interaction with AWS configs.
+    class AwsLogsService < Dogapi::APIService
+
+      API_VERSION = 'v1'
+
+      # Get the list of current AWS services for which Datadog offers automatic log collection.
+      # Use returned service IDs with the services parameter for the Enable
+      # an AWS service log collection API endpoint.
+      def aws_logs_list_services
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/integration/aws/logs/services", nil, nil, false)
+      end
+
+      # Create an AWS integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :account_id => '<AWS_ACCOUNT>',
+      #   :lambda_arn => '<LAMBDA_ARN>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.aws_logs_add_lambda(config)
+      def aws_logs_add_lambda(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/aws/logs", nil, config, true)
+      end
+
+      # List all Datadog-AWS Logs integrations configured in your Datadog account.
+      def aws_logs_integrations_list
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/integration/aws/logs", nil, nil, false)
+      end
+
+      # Enable automatic log collection for a list of services.
+      # This should be run after running 'aws_logs_add_lambda' to save the config.
+      # config = {
+      #   :account_id => '<AWS_ACCOUNT>',
+      #   :services => ['s3', 'elb', 'elbv2', 'cloudfront', 'redshift', 'lambda']
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.aws_logs_save_services(config)
+      def aws_logs_save_services(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/aws/logs/services", nil, config, true)
+      end
+
+      # Delete an AWS Logs integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :account_id => '<AWS_ACCOUNT>',
+      #   :lambda_arn => '<LAMBDA_ARN>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.aws_logs_integration_delete(config)
+      def aws_logs_integration_delete(config)
+        request(Net::HTTP::Delete, "/api/#{API_VERSION}/integration/aws/logs", nil, config, true)
+      end
+
+      # Check function to see if a lambda_arn exists within an account.
+      # This sends a job on our side if it does not exist, then immediately returns
+      # the status of that job. Subsequent requests will always repeat the above, so this endpoint
+      # can be polled intermittently instead of blocking.
+
+      # Returns a status of 'created' when it's checking if the Lambda exists in the account.
+      # Returns a status of 'waiting' while checking.
+      # Returns a status of 'checked and ok' if the Lambda exists.
+      # Returns a status of 'error' if the Lambda does not exist.
+
+      # contents of config should be
+      # >>> :account_id => '<AWS_ACCOUNT_ID>'
+      # >>> :lambda_arn => '<AWS_LAMBDA_ARN>'
+
+      def aws_logs_check_lambda(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/aws/logs/check_async", nil, config, true)
+      end
+
+      # Test if permissions are present to add log-forwarding triggers for the
+      # given services + AWS account. Input is the same as for save_services.
+      # Done async, so can be repeatedly polled in a non-blocking fashion until
+      # the async request completes
+
+      # Returns a status of 'created' when it's checking if the permissions exists in the AWS account.
+      # Returns a status of 'waiting' while checking.
+      # Returns a status of 'checked and ok' if the Lambda exists.
+      # Returns a status of 'error' if the Lambda does not exist.
+
+      # contents of config should be
+      # :account_id => '<AWS_ACCOUNT_ID>'
+      # :services => ['s3', 'elb', 'elbv2', 'cloudfront', 'redshift', 'lambda']
+      def aws_logs_check_services(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/aws/logs/services_async", nil, config, true)
+      end
+
+    end
+
+  end
+end

data/lib/dogapi/v1/azure_integration.rb

@@ -0,0 +1,81 @@
+require 'dogapi'
+
+module Dogapi
+  class V1 # for namespacing
+
+    # AzureIntegrationService for user interaction with Azure configs.
+    class AzureIntegrationService < Dogapi::APIService
+
+      API_VERSION = 'v1'
+
+      # Retrieve Azure integration information
+      def azure_integration_list
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/integration/azure", nil, nil, false)
+      end
+
+      # Delete an Azure integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :tenant_name => '<TENANT_NAME>',
+      #   :client_id => '<CLIENT_ID>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.azure_integration_delete(config)
+      def azure_integration_delete(config)
+        request(Net::HTTP::Delete, "/api/#{API_VERSION}/integration/azure", nil, config, true)
+      end
+
+      # Create an Azure integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :tenant_name => '<TENANT_NAME>',
+      #   :host_filters => 'new:filter',
+      #   :client_id => '<CLIENT_ID>',
+      #   :client_secret => '<CLIENT_SECRET>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.azure_integration_create(config)
+      def azure_integration_create(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/azure", nil, config, true)
+      end
+
+      # Update an Azure integrations host filters
+      # :config => Hash: integration config.
+      # config = {
+      #   :tenant_name => '<TENANT_NAME>',
+      #   :host_filters => 'new:filter',
+      #   :client_id => '<CLIENT_ID>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.azure_integration_update_host_filters(config)
+      def azure_integration_update_host_filters(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/azure/host_filters", nil, config, true)
+      end
+
+      # Update a configured Azure account.
+      # :config => Hash: integration config.
+      # config = {
+      #   :tenant_name => '<TENANT_NAME>',
+      #   :new_tenant_name => '<NEW_TENANT_NAME>',
+      #   :host_filters => '<KEY>:<VALUE>,<KEY>:<VALUE>',
+      #   :client_id => '<CLIENT_ID>',
+      #   :new_client_id => '<NEW_CLIENT_ID>'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.azure_integration_update(config)
+      def azure_integration_update(config)
+        request(Net::HTTP::Put, "/api/#{API_VERSION}/integration/azure", nil, config, true)
+      end
+
+    end
+
+  end
+end

data/lib/dogapi/v1/gcp_integration.rb

@@ -0,0 +1,72 @@
+require 'dogapi'
+
+module Dogapi
+  class V1 # for namespacing
+
+    # GcpIntegrationService for user interaction with gcp configs.
+    class GcpIntegrationService < Dogapi::APIService
+
+      API_VERSION = 'v1'
+
+      # Retrieve gcp integration information
+      def gcp_integration_list
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/integration/gcp", nil, nil, false)
+      end
+
+      # Delete an gcp integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :project_id => 'datadog-sandbox',
+      #   :client_email => 'email@example.com'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.gcp_integration_delete(config)
+      def gcp_integration_delete(config)
+        request(Net::HTTP::Delete, "/api/#{API_VERSION}/integration/gcp", nil, config, true)
+      end
+
+      # Create an gcp integration
+      # :config => Hash: integration config.
+      # config = {
+      #   :type => 'service_account',
+      #   :project_id => '<PROJECT_ID>',
+      #   :private_key_id => '<PRIVATE_KEY_ID>',
+      #   :private_key => '<PRIVATE_KEY>',
+      #   :client_email => '<CLIENT_EMAIL>',
+      #   :client_id => '<CLIENT_ID>',
+      #   :auth_uri => '<AUTH_URI>',
+      #   :token_uri => '<TOKEN_URI>',
+      #   :auth_provider_x509_cert_url => '<AUTH_PROVIDER_X509_CERT_URL>',
+      #   :client_x509_cert_url => '<CLIENT_X509_CERT_URL>',
+      #   :host_filters => '<KEY>:<VALUE>,<KEY>:<VALUE>,'
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.gcp_integration_create(config)
+      def gcp_integration_create(config)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/integration/gcp", nil, config, true)
+      end
+
+      # Update a configured gcp account.
+      # :config => Hash: integration config.
+      # config = {
+      #   :project_id => '<PROJECT_ID>',
+      #   :client_email => '<CLIENT_EMAIL>',
+      #   :host_filters => '<KEY>:<VALUE>,<KEY>:<VALUE>,'
+      #   :automute => true # takes a boolean and toggles GCE automuting
+      # }
+      #
+      # dog = Dogapi::Client.new(api_key, app_key)
+      #
+      # puts dog.gcp_integration_update(config)
+      def gcp_integration_update(config)
+        request(Net::HTTP::Put, "/api/#{API_VERSION}/integration/gcp", nil, config, true)
+      end
+
+    end
+
+  end
+end

data/lib/dogapi/v1/monitor.rb

@@ -2,9 +2,7 @@ require 'dogapi'
 
 module Dogapi
   class V1 # for namespacing
-
     class MonitorService < Dogapi::APIService
-
       API_VERSION = 'v1'
 
       def monitor(type, query, options = {})
@@ -42,6 +40,17 @@ module Dogapi
         request(Net::HTTP::Get, "/api/#{API_VERSION}/monitor/#{monitor_id}", extra_params, nil, false)
       end
 
+      def can_delete_monitors(monitor_ids)
+        extra_params =
+          if monitor_ids.respond_to?(:join)
+            { "monitor_ids" => monitor_ids.join(",") }
+          else
+            { "monitor_ids" => monitor_ids }
+          end
+
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/monitor/can_delete", extra_params, nil, false)
+      end
+
       def delete_monitor(monitor_id)
         request(Net::HTTP::Delete, "/api/#{API_VERSION}/monitor/#{monitor_id}", nil, nil, false)
       end
@@ -122,8 +131,8 @@ module Dogapi
         request(Net::HTTP::Put, "/api/#{API_VERSION}/downtime/#{downtime_id}", nil, options, true)
       end
 
-      def get_downtime(downtime_id)
-        request(Net::HTTP::Get, "/api/#{API_VERSION}/downtime/#{downtime_id}", nil, nil, false)
+      def get_downtime(downtime_id, options = {})
+        request(Net::HTTP::Get, "/api/#{API_VERSION}/downtime/#{downtime_id}", options, nil, false)
       end
 
       def cancel_downtime(downtime_id)
@@ -131,7 +140,7 @@ module Dogapi
       end
 
       def cancel_downtime_by_scope(scope)
-        request(Net::HTTP::Post, "/api/#{API_VERSION}/downtime/cancel/by_scope", nil, { 'scope' => scope }, false)
+        request(Net::HTTP::Post, "/api/#{API_VERSION}/downtime/cancel/by_scope", nil, { 'scope' => scope }, true)
       end
 
       def get_all_downtimes(options = {})

data/lib/dogapi/version.rb

@@ -1,3 +1,3 @@
 module Dogapi
-  VERSION = '1.37.1'
+  VERSION = '1.38.0'
 end

data/spec/integration/aws_integration_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../spec_helper'
+
+describe Dogapi::Client do
+  CONFIG = {
+    account_id: '123456789101',
+    role_name: 'DatadogApiTestRole'
+  }.freeze
+
+  UPDATE_CONFIG = {
+    account_id: '123456789102',
+    filter_tags: ['datadog:true'],
+    host_tags: ['api:test'],
+    role_name: 'DatadogApiTestRole'
+  }.freeze
+
+  describe '#aws_integration_create' do
+    it_behaves_like 'an api method',
+                    :aws_integration_create, [CONFIG],
+                    :post, '/integration/aws', CONFIG
+  end
+
+  describe '#aws_integration_list' do
+    it_behaves_like 'an api method',
+                    :aws_integration_list, nil,
+                    :get, '/integration/aws'
+  end
+
+  describe '#aws_integration_list_namespaces' do
+    it_behaves_like 'an api method',
+                    :aws_integration_list_namespaces, nil,
+                    :get, '/integration/aws/available_namespace_rules'
+  end
+
+  describe '#aws_integration_generate_external_id' do
+    it_behaves_like 'an api method',
+                    :aws_integration_generate_external_id, [CONFIG],
+                    :put, '/integration/aws/generate_new_external_id', CONFIG
+  end
+
+  describe '#aws_integration_update' do
+    it_behaves_like 'an api method with params and body',
+                    :aws_integration_update, [CONFIG, UPDATE_CONFIG],
+                    :put, '/integration/aws', CONFIG, UPDATE_CONFIG
+  end
+
+  describe '#aws_integration_delete' do
+    it_behaves_like 'an api method',
+                    :aws_integration_delete, [CONFIG],
+                    :delete, '/integration/aws', CONFIG
+  end
+end