datadog-exporter 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e95a0191b86630b9e7cf948cc9fffe4051329c001354d98a095bd3b3b65f107c
+  data.tar.gz: c528a1c2c768998bf8e618bf3afd70d384e6981c6ea6c7af94c26d588228b948
+SHA512:
+  metadata.gz: 42f8f7d7f0e538ed54350ef007fa7c07ce3312b5630113a4b9626c004771e82bb148bbf28e2411199291d0d39fa37df989f1a4c851e93ca34cbad8c8b8b1dc52
+  data.tar.gz: 03d1452fcf7b0fca965180340e251c8f3b342a3849ea61f250e01e133de1dc986476af75bb93e0d0363b067d0c4955c37cdd19bc3289d3ec0bf623c5b1b8ed27

data/lib/datadog_exporter/client/config.rb

@@ -0,0 +1,63 @@
+require "datadog_api_client"
+
+module DatadogExporter
+  class Client
+    ##
+    # The configuration for the DatadogExporter::Client.
+    class Config
+      DEFAULT_ORGANIZATIONS_CONFIGURATIONS = {
+        monitors: {
+          export_tag: "",
+          template_keys: [],
+          placeholders: {
+            base: {
+            },
+          },
+        },
+      }.freeze
+
+      attr_reader :logger
+
+      # NOTE: See DatadogExporter::Configurations to see the available options
+      def initialize(**options) # rubocop:disable Metrics/AbcSize
+        @site = options[:site] || DatadogExporter.configuration.site
+        @api_key = options[:api_key] || DatadogExporter.configuration.api_key
+        @application_key =
+          options[:application_key] || DatadogExporter.configuration.application_key
+        @logger = options[:logger] || DatadogExporter.configuration.logger
+        @base_path = options[:base_path] || DatadogExporter.configuration.base_path
+        @organizations_config_filename =
+          options[:org_config_filename] ||
+            DatadogExporter.configuration.organizations_config_filename
+      end
+
+      def base_path
+        Pathname.new(@base_path)
+      end
+
+      # Creates the Datadog API global configuration
+      #
+      # See https://github.com/DataDog/datadog-api-client-ruby/blob/master/lib/datadog_api_client/configuration.rb
+      def datadog_api_configuration
+        DatadogAPIClient::Configuration.new do |client_config|
+          client_config.server_variables[:site] = @site
+          client_config.api_key = @api_key
+          client_config.application_key = @application_key
+        end
+      end
+
+      def organizations_config
+        organizations_config_file = base_path.join(@organizations_config_filename)
+
+        unless File.exist?(organizations_config_file)
+          warn(
+            "WARNING: Organizations configuration file not found: #{organizations_config_file}. Using default configuration.",
+          )
+          return DEFAULT_ORGANIZATIONS_CONFIGURATIONS
+        end
+
+        DEFAULT_ORGANIZATIONS_CONFIGURATIONS.merge(YAML.load_file(organizations_config_file))
+      end
+    end
+  end
+end

data/lib/datadog_exporter/client.rb

@@ -0,0 +1,21 @@
+require_relative "client/config"
+
+module DatadogExporter
+  ##
+  # The client that makes the actual requests to the DatadogAPIClient.
+  # `config` is an instance of `DatadogApi::Client::Config::Base`
+  class Client
+    def initialize(config: DatadogExporter::Client::Config.new)
+      @datadog_config = config.datadog_api_configuration
+    end
+
+    # Creates the Datadog API client
+    #
+    # See https://github.com/DataDog/datadog-api-client-ruby/blob/master/lib/datadog_api_client/api_client.rb
+    #
+    # @return [DatadogAPIClient::APIClient]
+    def datadog_client
+      @datadog_client ||= DatadogAPIClient::APIClient.new(@datadog_config)
+    end
+  end
+end

data/lib/datadog_exporter/configuration.rb

@@ -0,0 +1,40 @@
+require "logger"
+
+module DatadogExporter
+  ##
+  # The global configuration of the DatadogExporter client.
+  #
+  # @see DatadogExporter.configure
+  class Configuration
+    def initialize
+      @config = {}
+    end
+
+    ##
+    # Create a getter and a setter for a setting.
+    #
+    # If the default value is a Proc, it will be called on initialize.
+    #
+    # @param name: Symbol
+    # @param default: Proc | Object
+    def self.add_setting(name, default)
+      define_method name do
+        @config[name] ||= default.is_a?(Proc) ? default.call : default
+      end
+
+      define_method :"#{name}=" do |value|
+        @config[name] = value
+      end
+    end
+
+    DEFAULT_ORG_CONFIG_FILENAME = "organizations_config.yml".freeze
+
+    add_setting :logger, -> { Logger.new($stdout) }
+    add_setting :base_path, -> { Dir.pwd }
+    add_setting :site, -> { ENV.fetch("DATADOG_API_SITE", nil) }
+    add_setting :api_key, -> { ENV.fetch("DATADOG_API_KEY", nil) }
+    add_setting :application_key, -> { ENV.fetch("DATADOG_APPLICATION_KEY", nil) }
+    add_setting :organizations_config_filename,
+                -> { ENV.fetch("DATADOG_ORG_CONFIG_FILENAME", DEFAULT_ORG_CONFIG_FILENAME) }
+  end
+end

data/lib/datadog_exporter/datadog_api_requests/monitors.rb

@@ -0,0 +1,56 @@
+module DatadogExporter
+  module DatadogApiRequests
+    # The class that contains all the Datadog API client requests for Monitors
+    class Monitors
+      attr_reader :monitors_api
+
+      def initialize(
+        config: DatadogExporter::Client::Config.new,
+        client: DatadogExporter::Client.new(config:),
+        monitors_api: DatadogAPIClient::V1::MonitorsAPI.new(client.datadog_client)
+      )
+        @client = client
+        @monitors_api = monitors_api
+      end
+
+      ##
+      # Returns a list of Hashes containing Datadog monitor configuration.
+      # If no tag is provided, it returns all the monitors.
+      #
+      # @param [String] tag (optional) A tag defined in the Datadog monitors
+      #
+      # @return [Array<Hash>] A list of monitor configurations
+      def list_monitors(tag: nil)
+        monitors =
+          @monitors_api
+            .list_monitors # NOTE: Unfortunately, the filter provided by the API is not working https://github.com/DataDog/datadog-api-client-ruby/issues/2063
+            .select { |monitor| tag.nil? || monitor.tags.include?(tag) }
+
+        monitors.map(&:to_hash)
+      end
+
+      ##
+      # Returns a Datadog monitor configuration.
+      #
+      # @param [Integer] monitor_id The monitor ID in Datadog
+      #
+      # @return [Hash] The monitor configuration
+      def find(monitor_id)
+        monitor = @monitors_api.get_monitor(monitor_id)
+        monitor.to_hash
+      end
+
+      ##
+      # Creates a monitor in Datadog
+      #
+      # @param [Hash] monitor_hash The monitor configuration
+      #
+      # @return [Integer] The monitor ID
+      def create(monitor_hash)
+        monitor = @monitors_api.create_monitor(monitor_hash)
+
+        monitor.id
+      end
+    end
+  end
+end

data/lib/datadog_exporter/datadog_api_requests.rb

@@ -0,0 +1,9 @@
+require_relative "datadog_api_requests/monitors"
+
+module DatadogExporter
+  ##
+  # The module that contains all the Datadog API client requests
+  # See https://github.com/DataDog/datadog-api-client-ruby
+  module DatadogApiRequests
+  end
+end

data/lib/datadog_exporter/monitors/export.rb

@@ -0,0 +1,90 @@
+module DatadogExporter
+  module Monitors
+    ##
+    # This class provide export tools for Datadog Monitors
+    class Export
+      attr_reader :config
+
+      def initialize(
+        config: DatadogExporter::Client::Config.new,
+        client: DatadogExporter::Client.new(config:),
+        request: DatadogExporter::DatadogApiRequests::Monitors.new(config:, client:),
+        name_transformer: Utilities::NameTransformer.new,
+        template_creator: Utilities::TemplateManager.new(config:),
+        file_class: File
+      )
+        @config = config
+        @request = request
+        @monitors_base_path = config.base_path.join(DatadogExporter::Monitors::EXPORT_FOLDER)
+        @name_transformer = name_transformer
+        @template_creator = template_creator
+        @file_class = file_class
+      end
+
+      ##
+      # Exports Datadog monitors configuration in YAML files.
+      # If no tag is provided, it exports all the monitors.
+      #
+      # @param [String] tag (optional) A tag defined in the Datadog monitors
+      #
+      # @return [String] Output message
+      def export(tag: nil)
+        reset_monitors_dir
+
+        monitors(tag:).each { |exported_datadog_hash| save_original(exported_datadog_hash) }
+
+        config.logger.info("Exported #{@monitors.count} monitors to #{@monitors_base_path}")
+      end
+
+      ##
+      # Exports Datadog monitors configuration in YAML files as templates.
+      # If no tag is provided, it exports all the monitors.
+      #
+      # See TemplateManager for more information about the transformation.
+      #
+      # @param [String] tag (optional) A tag defined in the Datadog monitors
+      #
+      # @return [String] Output message
+      def export_as_template(tag: nil)
+        reset_monitors_dir
+
+        monitors(tag:).each { |exported_datadog_hash| save_template(exported_datadog_hash) }
+
+        config.logger.info(
+          "Exported #{@monitors.count} monitor templates to #{@monitors_base_path}",
+        )
+      end
+
+      private
+
+      def monitors(tag:)
+        @monitors ||= @request.list_monitors(tag:)
+      end
+
+      def reset_monitors_dir
+        @monitors_base_path.mkpath unless @file_class.exist?(@monitors_base_path)
+
+        @monitors_base_path.glob("*.yml").each(&:delete)
+      end
+
+      def save_template(exported_datadog_hash)
+        save!(
+          "template.#{@name_transformer.transform(exported_datadog_hash[:name])}",
+          @template_creator.create_template(exported_datadog_hash).to_yaml,
+        )
+      end
+
+      def save_original(exported_datadog_hash)
+        save!(
+          @name_transformer.transform(exported_datadog_hash[:name]),
+          exported_datadog_hash.to_yaml,
+        )
+      end
+
+      def save!(name, yaml_data)
+        filepath = @monitors_base_path.join("#{name}.yml")
+        @file_class.write(filepath, yaml_data)
+      end
+    end
+  end
+end

data/lib/datadog_exporter/monitors/import.rb

@@ -0,0 +1,63 @@
+module DatadogExporter
+  module Monitors
+    ##
+    # This class provide import tools for Datadog Monitors
+    #
+    # Whether they are templates or original monitors, it imports them from the base_path/monitors folder.
+    class Import
+      def initialize(
+        config: DatadogExporter::Client::Config.new,
+        client: DatadogExporter::Client.new(config:),
+        request: DatadogExporter::DatadogApiRequests::Monitors.new(config:, client:),
+        template_manager: Utilities::TemplateManager.new(config:),
+        file_class: File
+      )
+        @config = config
+        @request = request
+        @monitors_base_path = config.base_path.join(DatadogExporter::Monitors::EXPORT_FOLDER)
+        @template_manager = template_manager
+        @file_class = file_class
+      end
+
+      ##
+      # Imports Datadog monitors configuration from YAML files.
+      #
+      #   * Loops all exported monitors in the base_path/monitors folder.
+      #   * Transforms the monitor into a template with placeholders.
+      #   * Replace the placeholders with the environment values
+      #   * Creates the monitor in the Datadog environment.
+      #
+      # If a tag is provided, it imports only the monitors with that tag.
+      #
+      # @param [Symbol] to The environment (defined in your organizations_config_filename) where the monitors will be imported
+      # @param [String] tag (optional) A tag defined in the Datadog monitors
+      def import(to:, tag: nil)
+        monitors
+          .select { |monitor| tag.nil? || monitor[:tags].include?(tag) }
+          .each do |monitor|
+            template = @template_manager.create_template(monitor)
+            target_monitor = @template_manager.create_monitor(template, environment: to)
+            @request.create(target_monitor) if accepted?(target_monitor, to)
+          end
+      end
+
+      private
+
+      def monitors
+        @monitors_base_path
+          .glob("*.yml")
+          .map do |file|
+            YAML.load_file(file, permitted_classes: [Symbol, Time, Date, DateTime, Object])
+          end
+      end
+
+      def accepted?(monitor, to)
+        puts monitor.to_yaml
+
+        print "Save to #{to} (y/n): "
+        input = gets.chomp.downcase
+        input == "y"
+      end
+    end
+  end
+end

data/lib/datadog_exporter/monitors/utilities/name_transformer.rb

@@ -0,0 +1,18 @@
+module DatadogExporter
+  module Monitors
+    module Utilities
+      ##
+      # This class transform the monitor name to a valid file name
+      class NameTransformer
+        # Transforms the monitor name to a valid file name
+        #
+        # @param [String] name The monitor name
+        #
+        # @return [String] The transformed name
+        def transform(name)
+          name.downcase.gsub(/\s*\|\s*/, "_").tr("/", "_").gsub(/\s+/, "_")
+        end
+      end
+    end
+  end
+end

data/lib/datadog_exporter/monitors/utilities/template_manager.rb

@@ -0,0 +1,126 @@
+module DatadogExporter
+  module Monitors
+    module Utilities
+      ##
+      # This class transform the monitor into a template
+      class TemplateManager
+        ##
+        # This class replaces the matching text with a placeholder
+        class StringToPlaceholder
+          attr_reader :original_string, :placeholders
+
+          def initialize(original_string, placeholders)
+            @original_string = original_string
+            @placeholders = placeholders
+          end
+
+          def replace
+            replaced_string = original_string.dup
+
+            placeholders.each do |placeholder_name, matching_text|
+              placeholder = "#{placeholder_name}_placeholder"
+              original_string.include?(matching_text) &&
+                replaced_string.gsub!(matching_text, placeholder)
+            end
+
+            replaced_string
+          end
+        end
+
+        ##
+        # This class replaces the matching placeholder with text
+        class PlaceholderToString
+          attr_reader :target_string, :placeholders
+
+          def initialize(placeholders, target_string)
+            @placeholders = placeholders
+            @target_string = target_string
+          end
+
+          def replace
+            replaced_string = target_string.dup
+
+            placeholders.each do |placeholder_name, target_text|
+              placeholder = "#{placeholder_name}_placeholder"
+              target_string.include?(placeholder) && replaced_string.gsub!(placeholder, target_text)
+            end
+
+            replaced_string
+          end
+        end
+
+        def initialize(config: DatadogExporter::Client::Config.new)
+          @config = config.organizations_config[:monitors]
+        end
+
+        # Transforms the monitor to a template
+        #
+        # @param [Hash] datadog_hash The monitor configuration
+        #
+        # @param [Symbol] environment (optional) The env tag name where the placeholders are defined
+        # Placeholders can be defined in a "organizations_config.yml" file
+        # See "organizations_config.example.yml" to see an example
+        #
+        # @return [Hash] The transformed monitor into a template with placeholders
+        # If no placeholder is defined, it returns the monitor as it is
+        def create_template(datadog_hash, environment: :base)
+          placeholders = @config[:placeholders][environment]
+
+          replace_values_with_placeholders(filter_by_template_keys(datadog_hash), placeholders)
+        end
+
+        def create_monitor(template, environment: :base)
+          placeholders = @config[:placeholders][environment]
+
+          replace_placeholders_with_values(placeholders, filter_by_template_keys(template))
+        end
+
+        private
+
+        def filter_by_template_keys(datadog_hash)
+          return datadog_hash if template_keys.empty?
+
+          datadog_hash.slice(*template_keys)
+        end
+
+        def replace_values_with_placeholders(hash_data, placeholders)
+          return hash_data if placeholders.nil?
+
+          hash_data.each do |key, value|
+            case value
+            when Hash
+              replace_values_with_placeholders(value, placeholders)
+            when String
+              hash_data[key] = StringToPlaceholder.new(value, placeholders).replace
+            when Array
+              hash_data[key] = value.map do |value|
+                StringToPlaceholder.new(value, placeholders).replace
+              end
+            end
+          end
+        end
+
+        def replace_placeholders_with_values(placeholders, hash_data)
+          return hash_data if placeholders.nil?
+
+          hash_data.each do |key, value|
+            case value
+            when Hash
+              replace_placeholders_with_values(placeholders, value)
+            when String
+              hash_data[key] = PlaceholderToString.new(placeholders, value).replace
+            when Array
+              hash_data[key] = value.map do |value|
+                PlaceholderToString.new(placeholders, value).replace
+              end
+            end
+          end
+        end
+
+        def template_keys
+          @config[:template_keys]
+        end
+      end
+    end
+  end
+end

data/lib/datadog_exporter/monitors.rb

@@ -0,0 +1,12 @@
+require_relative "monitors/utilities/name_transformer"
+require_relative "monitors/utilities/template_manager"
+require_relative "monitors/export"
+require_relative "monitors/import"
+
+module DatadogExporter
+  ##
+  # The module that contains all the Datadog Monitors related classes
+  module Monitors
+    EXPORT_FOLDER = "monitors".freeze
+  end
+end

data/lib/datadog_exporter/version.rb

@@ -0,0 +1,3 @@
+module DatadogExporter
+  VERSION = "0.2.0".freeze
+end

data/lib/datadog_exporter.rb

@@ -0,0 +1,34 @@
+require "datadog_exporter/configuration"
+require "datadog_exporter/client"
+require "datadog_exporter/datadog_api_requests"
+require "datadog_exporter/monitors"
+
+##
+# The DatadogExporter tool
+module DatadogExporter
+  # Returns the global `DatadogExporter::Configuration` object. While
+  # you _can_ use this method to access the configuration, the more common
+  # convention is to use `DatadogExporter.configure``
+  #
+  # @example
+  #     DatadogExporter.configuration.logger = Logger.new($stdout)
+  # @see DatadogExporter.configure
+  # @see DatadogExporter::Configuration
+  def self.configuration
+    @configuration ||= DatadogExporter::Configuration.new
+  end
+
+  # Yields the global configuration to a block.
+  # @yield [Configuration] global configuration
+  #
+  # @example
+  #     DatadogExporter.configure do |config|
+  #       config.logger = Logger.new($stdout)
+  #     end
+  # @see DatadogExporter::Configuration
+  def self.configure
+    raise ArgumentError, "Please provide a block to configure" unless block_given?
+
+    yield configuration
+  end
+end

data/lib/stubs/datadog_stub.rb

@@ -0,0 +1,12 @@
+module DatadogAPIClient
+  ##
+  # Stub for the Datadog API client to help Solargraph
+  #
+  # The reason of this stub is to help Solargraph to understand the code because
+  # it is rasing next error:
+  #
+  # .../gems/3.3.0/doc/datadog_api_client-2.27.1/.yardoc is too large to process (26824811 bytes)
+  # .../datadog_exporter/client.rb:17 - Unresolved return type DatadogAPIClient::APIClient for DatadogExporter::Client#datadog_client
+  class APIClient # rubocop:disable Lint/EmptyClass
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: datadog-exporter
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Fran Martinez
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description:
+email:
+- martinezcoder@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/datadog_exporter.rb
+- lib/datadog_exporter/client.rb
+- lib/datadog_exporter/client/config.rb
+- lib/datadog_exporter/configuration.rb
+- lib/datadog_exporter/datadog_api_requests.rb
+- lib/datadog_exporter/datadog_api_requests/monitors.rb
+- lib/datadog_exporter/monitors.rb
+- lib/datadog_exporter/monitors/export.rb
+- lib/datadog_exporter/monitors/import.rb
+- lib/datadog_exporter/monitors/utilities/name_transformer.rb
+- lib/datadog_exporter/monitors/utilities/template_manager.rb
+- lib/datadog_exporter/version.rb
+- lib/stubs/datadog_stub.rb
+homepage: https://github.com/datadog-exporter/datadog-exporter
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Exporting tools for Datadog
+test_files: []