newrelic_plugin 1.0.2

data/lib/newrelic_plugin/new_relic_message.rb

@@ -0,0 +1,173 @@
+require 'json'
+
+module NewRelic
+  module Plugin
+#
+# NewRelic driver. Provides all methods necessary for accessing the NewRelic service.
+# Used to store data into NewRelic service.
+#
+# Usage:
+#
+#   nrobj=NewRelic::Plugin::NewRelicConnection.new license_key:"xxx",host:"xxx",port:80,log_http:true,log_metrics:true # log_http,host and port are optional; license key is not.
+#   msg=nrobj.start_message <component_name>,<component_guid>,<component_version>,<duration_in_seconds>
+#   msg.add_stat basename,count_unit,value_unit,count,value,opts={} # opts can include :min, :max, and :sum_of_squares
+#   msg.send_message # Send the list of stats to New Relic
+#
+# Example:
+#   nrobj=NewRelic::Plugin::NewRelicConnection.new license_key:"bootstrap_newrelic_admin_license_key_000",host:"localhost",port:8081,log_http:true,log_metrics:true
+#   msg=nrobj.start_message "A Kewl Component","12345678","0.0.1",60
+#   msg.add_stat_fullname "Component/TestMetric1[Bytes/Seconds]",2,34,min:31,max:54,sum_of_squares:1234
+#   msg.add_stat_fullname "Component/AnotherTest[Bytes/Seconds]",2,34,min:31,max:54,sum_of_squares:1234
+#   msg.add_stat_fullname "Component/TestMetric2[Bytes/Seconds]",2,34,min:31,max:54,sum_of_squares:1234
+#   msg.add_stat_fullname "Component/AnotherMetric[Bytes/Seconds]",2,34,min:31,max:54,sum_of_squares:1234
+#   msg.send_metrics # Send the list of stats to New Relic
+#
+
+
+
+    class NewRelicMessage
+      #
+      #
+      # Create an object to send metrics
+      #
+      #
+      def initialize connection,component_name,component_guid,component_version,duration_in_seconds
+        @connection = connection
+        @component_name = component_name
+        @component_guid = component_guid
+        @component_version = component_version
+        @duration_in_seconds = duration_in_seconds
+        @metrics = [] # Metrics being saved
+      end
+      def add_stat_fullname metric_name,count,value,opts={}
+        entry = {}
+        entry[:metric_name] = metric_name
+        entry[:count] = count
+        entry[:total] = value
+        [:min,:max,:sum_of_squares].each do |key|
+          entry[key] = opts[key]
+        end
+        @metrics << entry
+      end
+
+      def metrics
+        @metrics
+      end
+
+      def send_metrics
+        return_errors = []
+        puts "Metrics for #{@component_name}[#{@component_guid}] for last #{@duration_in_seconds} seconds:" if new_relic_connection.log_metrics?
+        #
+        # Send all metrics in a single transaction
+        #
+        response = deliver_metrics
+        evaluate_response(response)
+        log_send_metrics
+      end
+
+      private
+
+      def build_metrics_hash
+        metrics_hash = {}
+        metrics.each do |metric|
+          metric_value = []
+          [:total,:count,:max,:min,:sum_of_squares].each do |key|
+            metric_value.push(metric[key]) if metric[key]
+          end
+          metrics_hash[metric[:metric_name]] = metric_value
+        end
+        return metrics_hash
+      end
+      
+      def build_request_payload
+        data = {
+          "agent" => {
+              "name" => @component_name,
+              "version" => @component_version,
+              "host" => ""
+          },
+          "components" => [
+              {
+                "name" => @component_name,
+                "guid" => @component_guid,
+                "duration" => @duration_in_seconds,
+                "metrics" => build_metrics_hash
+              } 
+          ]
+        }
+        return data.to_json
+      end
+
+      def deliver_metrics
+        begin
+          response = new_relic_connection.connect.post do |req|
+            req.url new_relic_connection.uri
+            req.headers['Content-Type'] = 'application/json'
+            req.body = build_request_payload
+          end
+        rescue => err
+          puts "HTTP Connection Error: #{err.inspect} #{err.message}"
+        end
+
+        return response
+      end
+
+      def evaluate_response(response)
+        return_status = nil
+        if response.nil?
+          last_result={"error" => "no response"}
+          return_status = "FAILED: No response"
+        elsif response && response.status == 200
+          last_result = JSON.parse(response.body)
+          if last_result["status"] != "ok"
+            return_status = "FAILED[#{response.status}] <#{new_relic_connection.url}>: #{last_result["error"]}"
+          end
+        elsif response && response.status == 403 && response.body == "DISABLE_NEW_RELIC"
+          puts "Agent has been disabled remotely by New Relic"
+          abort "Agent has been disabled remotely by New Relic"
+        else
+          begin
+            if response.body.size>0
+              last_result = JSON.parse(response.body)
+            else
+              last_result = {"error" => "no data returned"}
+            end
+            return_status = "FAILED[#{response.status}] <#{new_relic_connection.url}>: #{last_result["error"]}"
+          rescue => err
+            if response
+              return_status = "FAILED[#{response.status}] <#{new_relic_connection.url}>: Could not parse response: #{err}"
+            else
+              return_status = "FAILED: #{err}"
+            end
+          end
+        end
+        if return_status
+          if response and response.status == 503 and !new_relic_connection.log_metrics?
+            # If logging not enabled, and it's a 503...be less error-ish...
+            puts "  Collector temporarily unavailable...continuing"
+          else
+            # Otherwise, in all cases (logging enabled or not) print an error message
+            puts "  ****ERROR: #{return_status}"
+          end
+        end
+      end 
+
+      def log_send_metrics
+        if new_relic_connection.log_metrics?
+          puts "  Sent #{metrics.size} metrics to New Relic [#{new_relic_connection.url}]:"
+          metrics.each do |metric|
+            val_strs = []
+            [:count,:total,:min,:max,:sum_of_squares].each do |key|
+              val_strs << "#{key}: #{metric[key]}" if metric[key]
+            end
+            puts "    #{metric[:metric_name]}: #{val_strs.join(', ')}"
+          end
+        end
+      end
+
+      def new_relic_connection
+        @connection
+      end
+    end
+  end
+end

data/lib/newrelic_plugin/processor.rb

@@ -0,0 +1,18 @@
+module NewRelic
+  module Plugin
+    module Processor
+#
+#
+# Processor Base Class
+#
+#
+      class Base
+        attr_reader :ident,:label
+        def initialize ident,label
+          @ident=ident
+          @label=label
+        end
+      end
+    end
+  end
+end

data/lib/newrelic_plugin/processors/epoch_counter_processor.rb

@@ -0,0 +1,21 @@
+module NewRelic::Processor
+class EpochCounter<NewRelic::Plugin::Processor::Base
+    def initialize
+      super :epoch_counter,"Epoch Counter"
+    end
+    def process val
+      val=val.to_f
+      ret=nil
+      curr_time=Time.now
+      if @last_value and @last_time and curr_time>@last_time
+        ret=(val-@last_value)/(curr_time-@last_time).to_f
+      end
+      @last_value=val
+      @last_time=curr_time
+      # This next line is to avoid large negative spikes during epoch reset events...
+      return nil if ret.nil? or ret<0
+      ret
+    end
+    #Component::Setup.install_processor EpochCounter
+  end
+end

data/lib/newrelic_plugin/processors/rate_processor.rb

@@ -0,0 +1,35 @@
+module NewRelic::Processor
+  #
+  #
+  # OBSOLESCENCE WARNING!!!
+  #
+  # The "Rate" processor is being obsoleted. Please do not use in any new agent
+  # development.
+  #
+  # If you feel you need this processor, please check out the "Epoch Counter" processor
+  # and see if that will meet your needs. If not, then you can always do this calculation
+  # yourself within your agent.
+  #
+  # This processor will be removed from the code base shortly...
+  #
+  #
+  class Rate<NewRelic::Plugin::Processor::Base
+    def initialize
+      puts "OBSOLESCENCE WARNING: The 'Rate' processor is obsolete and should not be used."
+      puts "OBSOLESCENCE WARNING: It will be completely removed in the near future."
+      super :rate,"Rate"
+    end
+    def process val
+      val=val.to_f
+      ret=nil
+      curr_time=Time.now
+      if @last_value and @last_time and curr_time>@last_time
+        ret=(val-@last_value)/(curr_time-@last_time).to_f
+      end
+      @last_value=val
+      @last_time=curr_time
+      ret
+    end
+    #Component::Setup.install_processor Rate
+  end
+end

data/lib/newrelic_plugin/run.rb

@@ -0,0 +1,120 @@
+module NewRelic
+  module Plugin
+#
+# Run class. Provides entry points and polling initiation support.
+#
+# Author:: Lee Atchison <lee@newrelic.com>
+# Copyright:: Copyright (c) 2012 New Relic, Inc.
+#
+    class Run
+      #
+      # Primary Driver entry point
+      #
+      def self.setup_and_run component_type_filter=nil
+        run=new
+        run.setup_from_config component_type_filter
+        run.setup_no_config_agents
+        run.loop_forever
+      end
+      def initialize
+        @poll_cycle = (NewRelic::Plugin::Config.config.newrelic["poll"] || 60).to_i
+        @poll_cycle = 60 if (@poll_cycle <= 0) or (@poll_cycle >= 600)
+        puts "WARNING: Poll cycle differs from 60 seconds (current is #{@poll_cycle})" if @poll_cycle!=60
+      end
+      def installed_agents
+        if Setup.installed_agents.size==0
+          puts "No agents installed!"
+          raise NoAgents, "No agents installed"
+        end
+        Setup.installed_agents
+      end
+      #def installed_processors
+      #  Setup.installed_processors
+      #end
+      def configured_agents
+        agent_setup.agents
+      end
+      def setup_from_config component_type_filter=nil
+        return unless NewRelic::Plugin::Config.config.agents
+        installed_agents.each do |agent_id,installed_agent|
+          next if component_type_filter and agent_id!=component_type_filter
+          config_list=NewRelic::Plugin::Config.config.agents[agent_id.to_s]
+          next unless config_list
+          [config_list].flatten.each do |config|
+            next unless config
+            # Convert keys to symbols...
+            config.keys.each {|key|config[(key.to_sym rescue key) || key] = config.delete(key)}
+            name=config.delete(:name) # Pull out name and remove from hash
+            agent_setup.create_agent agent_id,name,config
+          end
+        end
+      end
+      #
+      # Add an entry for agents that require no configuration (and hence no instances)
+      #
+      def setup_no_config_agents
+        installed_agents.each do |agent_id,installed_agent|
+          unless installed_agent[:agent_class].config_required?
+            agent_setup.create_agent agent_id,installed_agent[:agent_class].label,{}
+          end
+        end
+      end
+      def setup &block
+        block.call(agent_setup)
+      end
+      #
+      # Call this method to loop forever. This will delay an appropriate amount until
+      # the next metric pull is needed, then it will loop thru all configured agents
+      # and call each one in turn so it can perform it's appropriate metric pull.
+      #
+      def loop_forever
+        if configured_agents.size==0
+          err_msg = "No agents configured!"
+          err_msg+= " Check the agents portion of your yml file." unless NewRelic::Plugin::Config.config.options.empty?
+          puts err_msg
+          raise NoAgents, err_msg
+        end
+        installed_agents.each do |agent_id,installed_agent|
+          version = installed_agent[:agent_class].version
+          puts "Agent #{installed_agent[:label]} is at version #{version}" if version
+        end
+        configured_agents.each do |agent|
+          agent.startup if agent.respond_to? :startup
+        end
+        @done=false
+        begin
+          while !@done
+            #
+            # Set last run time
+            @last_run_time=Time.now
+            #
+            # Call each agent
+            cnt=0
+            configured_agents.each do |agent|
+              begin
+                cnt+=agent.run @poll_cycle
+              rescue => err
+                puts "Error occurred in poll cycle: #{err}"
+              end
+            end
+            puts "Gathered #{cnt} statistics"
+            #
+            # Delay until next run
+            secs_to_delay=@poll_cycle-(Time.now-@last_run_time)
+            sleep secs_to_delay if secs_to_delay>0
+          end
+        rescue Interrupt =>err
+          puts "Shutting down..."
+        end
+        configured_agents.each do |agent|
+          agent.shutdown if agent.respond_to? :shutdown
+        end
+        puts "Shutdown complete"
+      end
+      #private
+      def agent_setup
+        @agent_setup||=AgentSetup.new
+      end
+    end
+  end
+end

data/lib/newrelic_plugin/setup.rb

@@ -0,0 +1,54 @@
+module NewRelic
+  module Plugin
+#
+# Setup support methods.
+#
+# Author:: Lee Atchison <lee@newrelic.com>
+# Copyright:: Copyright (c) 2012 New Relic, Inc.
+#
+    #
+    # Setup and Register new agent types and new processors
+    #
+    class Setup
+      class << self
+        def install_agent ident,klass
+          @installed_agents||={}
+          @installed_agents[ident] = {
+              :agent_class => klass::Agent,
+              :label => klass::Agent.label,
+              :ident => ident
+          }
+        end
+        #def install_processor klass
+        #  @installed_processors||={}
+        #  tmp_instance=klass.new
+        #  @installed_processors[tmp_instance.ident]={ident: tmp_instance.ident,processor_class: klass,label: tmp_instance.label}
+        #end
+        def installed_agents
+          @installed_agents||{}
+        end
+        #def installed_processors
+        #  @installed_processors||{}
+        #end
+      end
+    end
+
+    #
+    # Setup and instantiate new agent instances (of agent type previously setup in NewRelic::Plugin::Setup)
+    #
+    class AgentSetup
+      attr_reader :agents
+      def initialize
+        @agents=[]
+      end
+      def create_agent ident,name,options=nil,&block
+        agent_info=Setup.installed_agents[ident]
+        raise UnknownInstalledAgent,"Unrecognized agent '#{ident}'" unless agent_info
+        agent=agent_info[:agent_class].new name,agent_info,options
+        raise CouldNotInitializeAgent unless agent
+        block.call(agent) if block_given?
+        @agents<<agent
+      end
+    end
+  end
+end

data/lib/newrelic_plugin/simple_syntax.rb

@@ -0,0 +1,54 @@
+module NewRelic
+  module Plugin
+#
+#
+# SimpleSyntax:
+#
+# This is prototype code...the interface is not finalized nor is the implementation
+# complete. It's proof-of-concept only and subject to change without notice.
+#
+#
+    module SimpleSyntax
+      class Agent < NewRelic::Plugin::Agent::Base
+        no_config_required
+        class << self
+          def guid= guid
+            agent_guid guid
+          end
+          def version= version
+            agent_version version
+          end
+          def human_labels label,&block
+            agent_human_labels label,&block
+          end
+          def poll_cycle_proc= block
+            @@poll_cycle_proc = block
+          end
+        end
+        def poll_cycle
+          mod=Module.new
+          mod.send :define_method,:call_poll_cycle,@@poll_cycle_proc
+          self.extend mod
+          self.call_poll_cycle self
+        end
+      end
+    end
+
+    def self.setup
+      yield SimpleSyntax::Agent
+    end
+
+    def self.agent_config
+    end
+
+    def self.poll_cycle &block
+      SimpleSyntax::Agent.poll_cycle_proc = block
+    end
+
+    def self.run
+      NewRelic::Plugin::Setup.install_agent :simple_syntax,NewRelic::Plugin::SimpleSyntax
+      NewRelic::Plugin::Run.setup_and_run
+    end
+
+  end
+end