newrelic_plugin 1.0.3 → 1.2.1

data/lib/newrelic_plugin.rb

@@ -1,13 +1,10 @@
+require "newrelic_platform_binding"
 require "newrelic_plugin/version"
 require "newrelic_plugin/error"
 require "newrelic_plugin/config"
-require "newrelic_plugin/new_relic_connection"
-require "newrelic_plugin/new_relic_message"
 require "newrelic_plugin/agent"
-require "newrelic_plugin/data_collector"
 require "newrelic_plugin/setup" # cleanup needed
 require "newrelic_plugin/run" # cleanup needed
 require "newrelic_plugin/processor"
 require "newrelic_plugin/processors/epoch_counter_processor" # port needed
 require "newrelic_plugin/processors/rate_processor" # port needed
-require "newrelic_plugin/logger"

data/lib/newrelic_plugin/agent.rb

@@ -69,19 +69,15 @@ module NewRelic
         #
         # Instance Info
         #
-        attr_reader :name,:agent_info
+        attr_reader :name
         def guid
           return @guid if @guid
-          @guid=self.class.guid
+          @guid = self.class.guid
           #
           # Verify GUID is set correctly...
           #
-          if @guid=="guid" or @guid=="_TYPE_YOUR_GUID_HERE_"
-            #this feels tightly coupled to the config class, testing this is difficult, thinking about refactoring (NH)
-            @guid = NewRelic::Plugin::Config.config.newrelic['guids'][agent_info[:ident].to_s] if NewRelic::Plugin::Config.config.newrelic['guids']
-            Logger.write "NOTE: GUID updated for #{instance_label} at run-time to '#{@guid}'"
-          end
-          raise "Did not set GUID" if @guid.nil? or @guid=="" or @guid=="guid" or @guid=="_TYPE_YOUR_GUID_HERE_"
+          invalid_guids = ["", "guid", "_TYPE_YOUR_GUID_HERE_"]
+          raise "Did not set GUID" if @guid.nil? or invalid_guids.include?(@guid)
           @guid
         end
         def version
@@ -92,22 +88,22 @@ module NewRelic
         end
         #
         # Instantiate a newrelic_plugin instance
-        def initialize name,agent_info,options={}
-          @name=name
-          @agent_info=agent_info
-          @ident=agent_info[:ident]
-          @options=options
+        def initialize context, options = {}
+          @context = context
+          @options = options
           if self.class.config_options_list
             self.class.config_options_list.each do |config|
               self.send("#{config}=",options[config])
             end
           end
-          @last_time=nil
+          @last_time = nil
 
           #
           # Run agent-specific metric setup, if necessary
           setup_metrics if respond_to? :setup_metrics
+          @component = @context.create_component(instance_label, guid)
         end
+
         def instance_label
           if !respond_to? :instance_label_proc_method
             mod=Module.new
@@ -122,9 +118,9 @@ module NewRelic
         # Setup & Report Metrics
         #
         #
-        def report_metric metric_name,units,value,opts={}
+        def report_metric(metric_name, units, value, opts = {} )
           return if value.nil?
-          @data_collector.add_data metric_name,units,value.to_f,opts
+          @request.add_metric(@component, "Component/#{metric_name}[#{units}]", value, opts)
         end
 
         #
@@ -132,22 +128,19 @@ module NewRelic
         # Execute a poll cycle
         #
         #
-        def run poll_interval
+        def run(request)
+          @request = request
           #
           # Start of cycle work, if any
           cycle_start if respond_to? :cycle_start
 
           #
           # Collect Data
-          @data_collector=DataCollector.new self,poll_interval
           poll_cycle
-          cnt=@data_collector.process
-          @data_collector=nil
 
           #
           # End of cycle work, if any
           cycle_end if respond_to? :cycle_end
-          cnt
         end
       end
     end

data/lib/newrelic_plugin/config.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'erb'
 module NewRelic
   module Plugin
 #
@@ -24,7 +25,7 @@ module NewRelic
       # directly, rather the global method +config+ should be referenced instead.
       def initialize
         @options = YAML::load(Config.config_yaml) if Config.config_yaml
-        @options = YAML.load_file(Config.config_file) unless @options
+        @options = YAML::load(ERB.new(File.read(Config.config_file), 0, '<>').result) unless @options
       end
 
       #

data/lib/newrelic_plugin/processors/rate_processor.rb

@@ -13,10 +13,10 @@ module NewRelic::Processor
   # This processor will be removed from the code base shortly...
   #
   #
-  class Rate<NewRelic::Plugin::Processor::Base
+  class Rate < NewRelic::Plugin::Processor::Base
     def initialize
-      Logger.write "OBSOLESCENCE WARNING: The 'Rate' processor is obsolete and should not be used."
-      Logger.write "OBSOLESCENCE WARNING: It will be completely removed in the near future."
+      Logger.warn("OBSOLESCENCE WARNING: The 'Rate' processor is obsolete and should not be used.")
+      Logger.warn("OBSOLESCENCE WARNING: It will be completely removed in the near future.")
       super :rate,"Rate"
     end
     def process val

data/lib/newrelic_plugin/run.rb

@@ -2,50 +2,83 @@ 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
+      def self.setup_and_run component_type_filter = nil
+        run = new
         run.setup_from_config component_type_filter
         run.setup_no_config_agents
+        run.agent_startup
         run.loop_forever
+        run.agent_shutdown
       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)
-        Logger.write "WARNING: Poll cycle differs from 60 seconds (current is #{@poll_cycle})" if @poll_cycle!=60
+        @config = NewRelic::Plugin::Config.config
+        @context = NewRelic::Binding::Context.new(
+          @config.newrelic['license_key']
+        )
+        configuration_and_logging
+      end
+
+      def configuration_and_logging
+        if @config.newrelic["verbose"].to_i > 0
+          NewRelic::Logger.log_level = ::Logger::DEBUG
+        end
+        Logger.info("Using Ruby SDK version: #{NewRelic::Plugin::VERSION}")
+
+        if @config.newrelic['endpoint']
+          NewRelic::Binding::Config.endpoint = @config.newrelic['endpoint']
+          Logger.info("Using alternate endpoint: #{NewRelic::Binding::Config.endpoint}")
+        end
+
+        unless @config.newrelic['ssl_host_verification'].nil?
+          NewRelic::Binding::Config.ssl_host_verification = !!@config.newrelic['ssl_host_verification']
+          Logger.info("Disabling ssl host verification") unless NewRelic::Binding::Config.ssl_host_verification
+        end
+
+        if @config.newrelic['proxy']
+          NewRelic::Binding::Config.proxy = @config.newrelic['proxy']
+          Logger.info("Using a proxy: #{NewRelic::Binding::Config.proxy.inspect}")
+        end
+
+        @poll_cycle_period = (@config.newrelic["poll"] || 60).to_i
+        NewRelic::Binding::Config.poll_cycle_period = @poll_cycle_period
+        if @poll_cycle_period <= 0
+          message = "A poll cycle period less than or equal to 0 is invalid"
+          Logger.fatal(message)
+          abort message
+        end
+        if @poll_cycle_period != 60
+          Logger.warn("WARNING: Poll cycle period differs from 60 seconds (current is #{@poll_cycle_period})")
+        end
       end
+
       def installed_agents
-        if Setup.installed_agents.size==0
-          Logger.write "No agents installed!"
+        if Setup.installed_agents.size == 0
+          Logger.error("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
+
+      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]
+        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
+            config.keys.each { |key|config[(key.to_sym rescue key) || key] = config.delete(key) }
+            agent_setup.create_agent @context, agent_id, config
           end
         end
       end
@@ -62,58 +95,68 @@ module NewRelic
       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
+
+      def agent_startup
+        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?
-          Logger.write err_msg
+          err_msg += " Check the agents portion of your yml file." unless NewRelic::Plugin::Config.config.options.empty?
+          Logger.error(err_msg)
           raise NoAgents, err_msg
         end
         installed_agents.each do |agent_id,installed_agent|
           version = installed_agent[:agent_class].version
-          Logger.write "Agent #{installed_agent[:label]} is at version #{version}" if version
+          Logger.info("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
+      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
+        @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
-                Logger.write "Error occurred in poll cycle: #{err}"
-              end
-            end
-            Logger.write "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
+            @last_run_time = Time.now
+            request = @context.get_request()
+            run_agent_data_collection(request)
+            request.deliver
+            Logger.info("Gathered #{request.metric_count} statistics from #{request.component_count} components")
+
+            seconds_to_delay = @poll_cycle_period - (Time.now - @last_run_time)
+            sleep(seconds_to_delay) if seconds_to_delay > 0
+          end
+        rescue Interrupt => err
+          Logger.info "Shutting down..."
+        end
+      end
+
+      def run_agent_data_collection(request)
+        Logger.debug('Start collecting agent data for poll cycle')
+        configured_agents.each do |agent|
+          begin
+            agent.run(request)
+          rescue => err
+            Logger.error("Error occurred in poll cycle: #{err}")
           end
-        rescue Interrupt =>err
-          Logger.write "Shutting down..."
         end
+        Logger.debug('Finished collecting agent data for poll cycle')
+      end
+
+      def agent_shutdown
         configured_agents.each do |agent|
           agent.shutdown if agent.respond_to? :shutdown
         end
-        Logger.write "Shutdown complete"
+        Logger.info("Shutdown complete")
       end
-      #private
+
       def agent_setup
-        @agent_setup||=AgentSetup.new
+        @agent_setup ||= AgentSetup.new
       end
     end
   end

data/lib/newrelic_plugin/setup.rb

@@ -2,34 +2,24 @@ 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||={}
+        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||{}
+          @installed_agents || {}
         end
-        #def installed_processors
-        #  @installed_processors||{}
-        #end
       end
     end
 
@@ -39,15 +29,16 @@ module NewRelic
     class AgentSetup
       attr_reader :agents
       def initialize
-        @agents=[]
+        @agents = []
       end
-      def create_agent ident,name,options=nil,&block
-        agent_info=Setup.installed_agents[ident]
+      def create_agent context, ident, 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
+        agent = agent_info[:agent_class].new context, options
         raise CouldNotInitializeAgent unless agent
         block.call(agent) if block_given?
-        @agents<<agent
+        context.version = agent.version
+        @agents << agent
       end
     end
   end

data/lib/newrelic_plugin/version.rb

@@ -1,5 +1,5 @@
 module NewRelic
   module Plugin
-    VERSION = "1.0.3"
+    VERSION = "1.2.1"
   end
 end

data/newrelic_plugin.gemspec

@@ -25,15 +25,15 @@ Gem::Specification.new do |s|
                     "--main", "README.md"]
   s.extra_rdoc_files = %w[README.md LICENSE]
 
-  s.add_dependency 'faraday', '>= 0.8.1'
   s.add_dependency 'json'
 
   ## List your development dependencies here. Development dependencies are
   ## those that are only needed during development
-  #s.add_development_dependency "minitest"
-  #s.add_development_dependency "vcr"
-  s.add_development_dependency 'shoulda-context'
   s.add_development_dependency 'mocha'
+  s.add_development_dependency "minitest", '>= 5.0.6'
+  s.add_development_dependency 'fakeweb'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'timecop'
 
   s.files         = `git ls-files`.split($\)
   s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/test/newrelic_platform_binding/component_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class ComponentTest < Minitest::Test
+
+  def setup
+    @component = NewRelic::Binding::Component.new('name', 'com.test')
+  end
+
+  def test_that_component_responds_to_name
+    assert_equal 'name', @component.name
+  end
+
+  def test_that_component_responds_to_guid
+    assert_equal 'com.test', @component.guid
+  end
+end

data/test/newrelic_platform_binding/config_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+class ConfigTest < Minitest::Test
+
+  def setup
+    @endpoint = NewRelic::Binding::Config.endpoint
+    @ssl_host_verification = NewRelic::Binding::Config.ssl_host_verification
+    @uri = NewRelic::Binding::Config.uri
+    @poll_cycle_period = NewRelic::Binding::Config.poll_cycle_period
+  end
+
+  def teardown
+    NewRelic::Binding::Config.endpoint = @endpoint
+    NewRelic::Binding::Config.ssl_host_verification = @ssl_host_verification
+    NewRelic::Binding::Config.uri = @uri
+    NewRelic::Binding::Config.poll_cycle_period = @poll_cycle_period
+  end
+
+  def test_use_ssl_with_https_url
+    NewRelic::Binding::Config.endpoint = 'https://example.com'
+    assert_equal true, NewRelic::Binding::Config.use_ssl?
+  end
+
+  def test_use_ssl_with_http_url
+    NewRelic::Binding::Config.endpoint = 'http://example.com'
+    assert_equal false, NewRelic::Binding::Config.use_ssl?
+  end
+
+  def test_ssl_supported
+    assert_equal NewRelic::Binding::Config.ssl_supported?, !(!defined?(RUBY_ENGINE) || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9.0'))
+  end
+
+  def test_endpoint_default
+    if NewRelic::Binding::Config.ssl_supported?
+      assert_equal 'https://platform-api.newrelic.com', NewRelic::Binding::Config.endpoint
+    else
+      assert_equal 'http://platform-api.newrelic.com', NewRelic::Binding::Config.endpoint
+    end
+  end
+
+  def test_set_endpoint
+    new_endpoint = 'http://example.com'
+    NewRelic::Binding::Config.endpoint = new_endpoint
+    assert_equal new_endpoint, NewRelic::Binding::Config.endpoint
+  end
+
+  def test_set_ssl_endpoint
+    new_endpoint = 'https://example.com'
+    if NewRelic::Binding::Config.ssl_supported?
+      NewRelic::Logger.expects(:warn).with('Using SSL is not recommended when using Ruby versions below 1.9').never
+    else
+      NewRelic::Logger.expects(:warn).with('Using SSL is not recommended when using Ruby versions below 1.9')
+    end
+    NewRelic::Binding::Config.endpoint = new_endpoint
+    assert_equal new_endpoint, NewRelic::Binding::Config.endpoint
+  end
+
+  def test_uri_default
+    assert_equal '/platform/v1/metrics', NewRelic::Binding::Config.uri
+  end
+
+  def test_set_uri
+    new_uri = '/foo'
+    NewRelic::Binding::Config.uri = new_uri
+    assert_equal new_uri, NewRelic::Binding::Config.uri
+  end
+
+  def test_ssl_host_verification_default
+    assert_equal true, NewRelic::Binding::Config.ssl_host_verification
+    assert_equal false, NewRelic::Binding::Config.skip_ssl_host_verification?
+  end
+
+  def test_set_ssl_host_verification
+    new_ssl_host_verification = false
+    NewRelic::Binding::Config.ssl_host_verification = new_ssl_host_verification
+    assert_equal new_ssl_host_verification, NewRelic::Binding::Config.ssl_host_verification
+    assert_equal true, NewRelic::Binding::Config.skip_ssl_host_verification?
+  end
+
+  def test_poll_cycle_period
+    assert_equal 60, NewRelic::Binding::Config.poll_cycle_period
+  end
+
+  def test_set_poll_cycle_period
+    new_poll_cycle_period = 120
+    NewRelic::Binding::Config.poll_cycle_period = new_poll_cycle_period
+    assert_equal new_poll_cycle_period, NewRelic::Binding::Config.poll_cycle_period
+  end
+end