newrelic-management 0.1.1

data/lib/newrelic-management/client.rb

@@ -0,0 +1,138 @@
+# Encoding: UTF-8
+# rubocop: disable LineLength
+#
+# Gem Name:: newrelic-management
+# NewRelicManagement:: Client
+#
+# Copyright (C) 2017 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'faraday'
+require 'faraday_middleware'
+require 'newrelic-management/config'
+require 'uri'
+
+module NewRelicManagement
+  # => NewRelic Manager Client
+  module Client
+    module_function
+
+    # => Build the HTTP Connection
+    def nr_api
+      # => Build the Faraday Connection
+      @conn ||= Faraday::Connection.new('https://api.newrelic.com', conn_opts) do |client|
+        client.use Faraday::Response::RaiseError
+        client.use FaradayMiddleware::EncodeJson
+        client.use FaradayMiddleware::ParseJson, content_type: /\bjson$/
+        client.response :logger if Config.environment.to_s.casecmp('development').zero? # => Log Requests to STDOUT
+        client.adapter Faraday.default_adapter #:net_http_persistent
+      end
+    end
+
+    def conn_opts
+      {
+        headers: {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json',
+          'X-api-key' => Config.nr_api_key
+        },
+        # => ssl: ssl_options
+      }
+    end
+
+    #
+    # => Alerts
+    #
+
+    # => List Alert Policies
+    def alert_policies
+      nr_api.get(url('alerts_policies')).body['policies']
+    rescue NoMethodError
+      []
+    end
+
+    # => List Alert Conditions
+    def alert_conditions(policy)
+      nr_api.get(url('alerts_conditions'), policy_id: policy).body
+    end
+
+    # => Add an Entitity to an Existing Alert Policy
+    def alert_add_entity(entity_id, condition_id, entity_type = 'Server')
+      nr_api.put do |req|
+        req.url url('alerts_entity_conditions', entity_id)
+        req.params['entity_type'] = entity_type
+        req.params['condition_id'] = condition_id
+      end
+    end
+
+    # => Delete an Entitity from an Existing Alert Policy
+    def alert_delete_entity(entity_id, condition_id, entity_type = 'Server')
+      nr_api.delete do |req|
+        req.url url('alerts_entity_conditions', entity_id)
+        req.params['entity_type'] = entity_type
+        req.params['condition_id'] = condition_id
+      end
+    end
+
+    # => List the Labels
+    def labels
+      nr_api.get(url('labels')).body['labels']
+    rescue NoMethodError
+      []
+    end
+
+    #
+    # => Servers
+    #
+
+    # => List the Servers Reporting to NewRelic
+    def servers
+      nr_api.get(url('servers')).body['servers']
+    rescue NoMethodError
+      []
+    end
+
+    # => Get Info for Specific Server
+    def get_server(server)
+      srv = get_server_id(server)
+      srv ? srv : get_server_name(server)
+    end
+
+    # => Get a Server based on ID
+    def get_server_id(server_id)
+      return nil unless server_id =~ /^[0-9]+$/
+      ret = nr_api.get(url('servers', server_id)).body
+      ret['server']
+    rescue Faraday::ResourceNotFound, NoMethodError
+      nil
+    end
+
+    # => Get a Server based on Name
+    def get_server_name(server, exact = true)
+      ret = nr_api.get(url('servers'), 'filter[name]' => server).body
+      return ret['servers'] unless exact
+      ret['servers'].find { |x| x['name'].casecmp(server).zero? }
+    rescue NoMethodError
+      nil
+    end
+
+    # => List the Servers with a Label
+    def get_servers_labeled(labels)
+      label_query = Array(labels).reject { |x| !x.include?(':') }.join(';')
+      return [] unless label_query
+      nr_api.get(url('servers'), 'filter[labels]' => label_query).body
+    end
+
+    # => Delete a Server from NewRelic
+    def delete_server(server_id)
+      nr_api.delete(url('servers', server_id)).body
+    end
+
+    def url(*args)
+      '/v2/' + args.map { |a| URI.encode_www_form_component a.to_s }.join('/') + '.json'
+    end
+    private :url
+  end
+end

data/lib/newrelic-management/config.rb

@@ -0,0 +1,107 @@
+# Encoding: UTF-8
+#
+# Gem Name:: newrelic-management
+# NewRelicManagement:: Config
+#
+# Copyright (C) 2017 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'newrelic-management/helpers/configuration'
+require 'pathname'
+
+module NewRelicManagement
+  # => This is the Configuration module.
+  module Config
+    module_function
+
+    extend Configuration
+
+    # => Gem Root Directory
+    define_setting :root, Pathname.new(File.expand_path('../../../', __FILE__))
+
+    # => My Name
+    define_setting :author, 'Brian Dwyer - Intelligent Digital Services'
+
+    # => Application Environment
+    define_setting :environment, :production
+
+    # => Config File
+    define_setting :config_file, File.join(root, 'config', 'config.json')
+
+    # => NewRelic API Key
+    define_setting :nr_api_key, nil
+
+    # => Daemonization
+    define_setting :daemonize, false
+
+    # => Silence Notifications
+    define_setting :silent, false
+
+    #
+    # => Alert Management
+    #
+
+    # => Array of Alerts to Manage
+    define_setting :alerts, []
+
+    # => How often to run when Daemonized
+    define_setting :alert_management_interval, '1m'
+
+    # => Find entities matching any tag, instead of all tags
+    define_setting :alert_match_any, false
+
+    #
+    # => Stale Server Management
+    #
+
+    # => Enable Stale Server Cleanup
+    define_setting :cleanup, false
+
+    # => Set a Time to keep Non-Reporting Servers
+    define_setting :cleanup_age, nil
+
+    # => How often to run when Daemonized
+    define_setting :cleanup_interval, '1m'
+
+    #
+    # => Transient Configuration
+    #
+    define_setting :transient, {}
+
+    #
+    # => Facilitate Dynamic Addition of Configuration Values
+    #
+    # => @return [class_variable]
+    #
+    def add(config = {})
+      config.each do |key, value|
+        define_setting key.to_sym, value
+      end
+    end
+
+    #
+    # => Facilitate Dynamic Removal of Configuration Values
+    #
+    # => @return nil
+    #
+    def clear(config)
+      Array(config).each do |setting|
+        delete_setting setting
+      end
+    end
+
+    #
+    # => List the Configurable Keys as a Hash
+    #
+    # @return [Hash]
+    #
+    def options
+      map = Config.class_variables.map do |key|
+        [key.to_s.tr('@', '').to_sym, class_variable_get(:"#{key}")]
+      end
+      Hash[map]
+    end
+  end
+end

data/lib/newrelic-management/controller.rb

@@ -0,0 +1,61 @@
+# Encoding: UTF-8
+#
+# Gem Name:: newrelic-management
+# NewRelicManagement:: Controller
+#
+# Copyright (C) 2017 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'newrelic-management/config'
+require 'newrelic-management/manager'
+require 'newrelic-management/notifier'
+require 'os'
+require 'rufus-scheduler'
+
+module NewRelicManagement
+  # => Utility Methods
+  module Controller
+    module_function
+
+    # => Daemonization for Periodic Management
+    def daemon # rubocop: disable AbcSize, MethodLength
+      # => Windows Workaround (https://github.com/bdwyertech/newrelic-management/issues/1)
+      ENV['TZ'] = 'UTC' if OS.windows? && !ENV['TZ']
+
+      scheduler = Rufus::Scheduler.new
+      Notifier.msg('Daemonizing Process')
+
+      # => Alerts Management
+      alerts_interval = Config.alert_management_interval
+      scheduler.every alerts_interval, overlap: false do
+        Manager.manage_alerts
+      end
+
+      # => Cleanup Stale Servers
+      if Config.cleanup
+        cleanup_interval = Config.cleanup_interval
+        cleanup_age = Config.cleanup_age
+
+        scheduler.every cleanup_interval, overlap: false do
+          Manager.remove_nonreporting_servers(cleanup_age)
+        end
+      end
+
+      # => Join the Current Thread to the Scheduler Thread
+      scheduler.join
+    end
+
+    # => Run the Application
+    def run
+      daemon if Config.daemonize
+
+      # => Manage Alerts
+      Manager.manage_alerts
+
+      # => Manage
+      Manager.remove_nonreporting_servers(Config.cleanup_age) if Config.cleanup
+    end
+  end
+end

data/lib/newrelic-management/helpers/configuration.rb

@@ -0,0 +1,57 @@
+# Encoding: UTF-8
+#
+# Gem Name:: newrelic-management
+# Helper:: Configuration
+#
+# Author: Eli Fatsi - https://www.viget.com/articles/easy-gem-configuration-variables-with-defaults
+# Contributor: Brian Dwyer - Intelligent Digital Services
+#
+
+# => Configuration Helper Module
+module Configuration
+  #
+  # => Provides a method to configure an Application
+  # => Example:
+  #      NewRelicManagement::Config.setup do |cfg|
+  #        cfg.config_file = 'abc.json'
+  #        cfg.app_name = 'GemBase'
+  #      end
+  #
+  def setup
+    yield self
+  end
+
+  def define_setting(name, default = nil)
+    class_variable_set("@@#{name}", default)
+
+    define_class_method "#{name}=" do |value|
+      class_variable_set("@@#{name}", value)
+    end
+
+    define_class_method name do
+      class_variable_get("@@#{name}")
+    end
+  end
+
+  def delete_setting(name)
+    remove_class_variable("@@#{name}")
+
+    delete_class_method(name)
+  rescue NameError # => Handle Non-Existent Settings
+    return
+  end
+
+  private
+
+  def define_class_method(name, &block)
+    (class << self; self; end).instance_eval do
+      define_method name, &block
+    end
+  end
+
+  def delete_class_method(name)
+    (class << self; self; end).instance_eval do
+      undef_method name
+    end
+  end
+end

data/lib/newrelic-management/manager.rb

@@ -0,0 +1,171 @@
+# Encoding: UTF-8
+# rubocop: disable LineLength
+#
+# Gem Name:: newrelic-management
+# NewRelicManagement:: Manager
+#
+# Copyright (C) 2017 Brian Dwyer - Intelligent Digital Services
+#
+# All rights reserved - Do Not Redistribute
+#
+
+require 'chronic_duration'
+require 'json'
+require 'newrelic-management/client'
+require 'newrelic-management/config'
+require 'newrelic-management/notifier'
+
+module NewRelicManagement
+  # => Manager Methods
+  module Manager
+    module_function
+
+    ######################
+    # =>    Alerts    <= #
+    ######################
+
+    # => Manage Alerts
+    def manage_alerts
+      Array(Config.alerts).each do |alert|
+        # => Set the Filtering Policy
+        Config.transient[:alert_match_any] = alert[:match_any] ? true : false
+
+        # => Manage the Alerts
+        manage_alert(alert[:name], alert[:labels], alert[:exclude])
+      end
+    end
+
+    def manage_alert(alert, labels, exclude = []) # rubocop: disable AbcSize
+      conditions = find_alert_conditions(alert) || return
+      tagged_entities = find_labeled(labels)
+      excluded = find_excluded(exclude)
+
+      conditions.each do |condition|
+        next unless condition['type'] == 'servers_metric'
+        existing_entities = condition['entities']
+
+        to_add = tagged_entities.map(&:to_i) - existing_entities.map(&:to_i) - excluded
+        to_delete = excluded & existing_entities.map(&:to_i)
+
+        add_to_alert(to_add, condition['id'])
+        delete_from_alert(to_delete, condition['id'])
+      end
+    end
+
+    def add_to_alert(entities, condition_id, type = 'Server')
+      return if entities.empty?
+      Notifier.add_servers(entities)
+      Array(entities).each do |entity|
+        Client.alert_add_entity(entity, condition_id, type)
+      end
+    end
+
+    def delete_from_alert(entities, condition_id, type = 'Server')
+      return if entities.empty?
+      Notifier.remove_servers(entities)
+      Array(entities).each do |entity|
+        Client.alert_delete_entity(entity, condition_id, type)
+      end
+    end
+
+    # => Find Matching Alert (Name or ID)
+    def find_alert(alert)
+      id = Integer(alert) rescue nil # rubocop: disable RescueModifier
+      list_alerts.find do |policy|
+        return policy if id && policy['id'] == id
+        policy['name'].casecmp(alert).zero?
+      end
+    end
+
+    # => Find Alert Conditions for a Matching Alert Policy
+    def find_alert_conditions(alert)
+      alert = find_alert(alert)
+      list_alert_conditions(alert['id'])['conditions'] if alert
+    end
+
+    # => Simply List Alerts
+    def list_alerts
+      Util.cachier('list_alerts') { Client.alert_policies }
+    end
+
+    # => List All Alert Conditions for an Alert Policy
+    def list_alert_conditions(policy_id)
+      Util.cachier("alert_conditions_#{policy_id}") { Client.alert_conditions(policy_id) }
+    end
+
+    #######################
+    # =>    Servers    <= #
+    #######################
+
+    # => Servers with the oldest `last_reported_at` will be at the top
+    def list_servers
+      Util.cachier('list_servers') do
+        Client.servers.sort_by { |hsh| hsh['last_reported_at'] }.collect do |server|
+          {
+            name: server['name'],
+            last_reported_at: server['last_reported_at'],
+            id: server['id'],
+            reporting: server['reporting']
+          }
+        end
+      end
+    end
+
+    def list_nonreporting_servers
+      list_servers.reject { |server| server[:reporting] }
+    end
+
+    # => Remove Non-Reporting Servers
+    def remove_nonreporting_servers(keeptime = nil)
+      list_nonreporting_servers.each do |server|
+        next if keeptime && Time.parse(server[:last_reported_at]) >= Time.now - ChronicDuration.parse(keeptime)
+        Notifier.msg(server[:name], 'Removing Stale, Non-Reporting Server')
+        Client.delete_server(server[:id])
+      end
+    end
+
+    # => Find Servers which should be excluded from Management
+    def find_excluded(excluded)
+      result = []
+      Array(excluded).each do |exclude|
+        if exclude.include?(':')
+          find_labeled(exclude).each { |x| result << x }
+          next
+        end
+        res = Client.get_server(exclude)
+        result << res['id'] if res
+      end
+      result
+    end
+
+    ######################
+    # =>    Labels    <= #
+    ######################
+
+    def list_labels
+      Util.cachier('list_labels') { Client.labels }
+    end
+
+    # => Find Servers Matching a Label
+    # => Example: find_labeled(['Role:API', 'Environment:Production'])
+    def find_labeled(labels, match_any = Config.transient[:alert_match_any]) # rubocop: disable AbcSize
+      list = list_labels
+      labeled = []
+      Array(labels).select do |lbl|
+        list.select { |x| x['key'].casecmp(lbl).zero? }.each do |mtch|
+          labeled.push(Array(mtch['links']['servers']))
+        end
+      end
+
+      unless match_any
+        # => Array(labeled) should contain one array per label
+        # => # => If it does not, it means the label is missing or misspelled
+        return [] unless labeled.count == Array(labels).count
+
+        # => Return Only those matching All Labels
+        return Util.common_array(labeled)
+      end
+      labeled.flatten.uniq
+    end
+  end
+end