newrelic_plugin 1.0.3 → 1.2.1

data/.gitignore

@@ -1 +1,2 @@
 Gemfile.lock
+*.swp

data/CHANGELOG.md

@@ -4,7 +4,50 @@
 
 **Features**
 
-* To fill in
+
+### v1.2.1 - September 10, 2013 ###
+
+**Bug Fixes**
+
+* Send agent version to the HTTP API, not the SDK version.
+* Stop using SSL by default in Ruby versions below 1.9 (this fixes an issue where the agent stops reporting)
+* Set timeouts on HTTP API connection (fixes an issue where the agent stops reporting in Ruby 1.9 and higher)
+
+
+### v1.2.0 - August 19, 2013 ###
+
+**Features**
+
+* Aggregate data when the collector is unreachable.
+
+**Bug Fixes**
+
+* Fixed issue where the ssl_host_verification flag was not working.
+* Fixed ordering of min and max in metric array that is sent to the HTTP API.
+
+
+### v1.1.1 - August 13, 2013 ###
+
+**Bug Fixes**
+
+* Fixed issue where to_set method was not found when requiring this gem without using bundler.
+* Added JSON as a dependency to provide Ruby 1.8.7 support.
+
+### v1.1.0 - August 5, 2013 ###
+
+**Features**
+
+* Improved logging
+* Support for proxies
+
+**Bug Fixes**
+
+* Duration of data collection time is now calculated to match actual duration
+
+**Changes**
+
+* Dropped dependency on Faraday
+
 ### v1.0.3 - June 25, 2013 ###
 
 **Features**

data/README.md

@@ -2,9 +2,16 @@
 
 ## Requirements
 
- * Tested with Ruby 1.8.7 and 1.9.3
- * New Relic account on rpm.newrelic.com, with early access enabled 
-   (contact cooper@newrelic.com to set up early access)
+ * Tested with Ruby 1.8.7, 1.9.3, 2.0.0
+ 
+ Note: In Ruby 1.8.7 SSL is disabled by default due to issues with how Net::HTTP handles connection timeouts. 
+If you override this the plugin may occasionally stop reporting data and require a restart.
+To override you can add the following to `newrelic:` section of the newrelic_config.yml. 
+
+```
+ endpoint: 'https://platform-api.newrelic.com'
+```
+
 
 ## Get Started
 
@@ -36,8 +43,7 @@ Reach out to us at
 There you'll find documentation, FAQs, and forums where you can submit
 suggestions and discuss with staff and other users.
 
-Also available is community support on IRC: we generally use #newrelic
-on irc.freenode.net
+Also available is [community support on Stack Overflow](http://stackoverflow.com/questions/tagged/newrelic-platform).
 
 Find a bug? E-mail <support@newrelic.com>, or submit a ticket to
 

data/lib/newrelic_platform_binding.rb

@@ -0,0 +1,11 @@
+require 'newrelic_platform_binding/logger'
+require 'newrelic_platform_binding/config'
+require 'newrelic_platform_binding/request'
+require 'newrelic_platform_binding/context'
+require 'newrelic_platform_binding/component'
+require 'newrelic_platform_binding/metric'
+require 'newrelic_platform_binding/connection'
+
+################################################################################
+# This is a Provisional API which is subject to change.
+################################################################################

data/lib/newrelic_platform_binding/component.rb

@@ -0,0 +1,27 @@
+module NewRelic
+  module Binding
+    class Component
+      attr_reader :name, :guid
+      attr_accessor :last_delivered_at
+
+      def initialize(name, guid)
+        @name = name
+        @guid = guid
+        @last_delivered_at = nil
+      end
+
+      def key
+        return (name + guid)
+      end
+
+      def duration
+        if last_delivered_at.nil?
+          return NewRelic::Binding::Config.poll_cycle_period
+        else
+          return (Time.now - last_delivered_at).ceil
+        end
+      end
+
+    end
+  end
+end

data/lib/newrelic_platform_binding/config.rb

@@ -0,0 +1,39 @@
+module NewRelic
+  module Binding
+    class Config
+      def self.endpoint=(url)
+        @endpoint = url
+        if self.use_ssl? and !self.ssl_supported?
+          Logger.warn('Using SSL is not recommended when using Ruby versions below 1.9')
+        end
+      end
+
+      def self.use_ssl?
+        @endpoint.start_with?('https')
+      end
+
+      def self.ssl_supported?
+        !(!defined?(RUBY_ENGINE) || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9.0'))
+      end
+
+      def self.skip_ssl_host_verification?
+        !@ssl_host_verification
+      end
+
+      if self.ssl_supported?
+        @endpoint = 'https://platform-api.newrelic.com'
+      else
+        @endpoint = 'http://platform-api.newrelic.com'
+        Logger.warn('SSL is disabled by default when using Ruby 1.8.x')
+      end
+      @uri = '/platform/v1/metrics'
+      @ssl_host_verification = true
+      @poll_cycle_period = 60
+      @proxy = nil
+      class << self
+        attr_accessor :ssl_host_verification, :uri, :poll_cycle_period, :proxy
+        attr_reader :endpoint
+      end
+    end
+  end
+end

data/lib/newrelic_platform_binding/connection.rb

@@ -0,0 +1,86 @@
+require 'json'
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+module NewRelic
+  module Binding
+    class Connection
+      attr_reader :license_key, :url
+
+      def initialize(context)
+        @url = Config.endpoint + Config.uri
+        @license_key = context.license_key
+      end
+
+      def send_request(data)
+        begin
+          Logger.debug("JSON payload: #{data}")
+          uri = URI.parse(url)
+          if Config.proxy.nil?
+            http = Net::HTTP.new(uri.host, uri.port)
+          else
+            proxy = Config.proxy
+            http = Net::HTTP.new(uri.host, uri.port, proxy['address'], proxy['port'], proxy['user'], proxy['password'])
+          end
+          if Config.use_ssl?
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE if Config.skip_ssl_host_verification?
+          end
+          http.open_timeout = 20
+          http.read_timeout = 20
+          request = Net::HTTP::Post.new(uri.path)
+          request['content-type'] = 'application/json'
+          request['X-License-Key'] = @license_key
+          request.body = data
+          response = http.request(request)
+          return evaluate_response(response)
+        rescue Timeout::Error => err
+          Logger.warn "Connection Timeout Error: #{err.inspect} #{err.message}"
+          return false
+        rescue => err
+          Logger.warn "HTTP Connection Error: #{err.inspect} #{err.message}"
+          return false
+        end
+      end
+
+    private
+      def evaluate_response(response)
+        return_status = nil
+        begin
+          if response.nil?
+            last_result = { "error" => "no response" }
+            return_status = "FAILED: No response"
+          elsif response && response.code == '200'
+            last_result = JSON.parse(response.body)
+            if last_result["status"] != "ok"
+              return_status = "FAILED[#{response.code}] <#{url}>: #{last_result["error"]}"
+            end
+          elsif response && response.code == '403' && response.body == "DISABLE_NEW_RELIC"
+            Logger.fatal "Agent has been disabled remotely by New Relic"
+            abort "Agent has been disabled remotely by New Relic"
+          else
+            if response.body.size > 0
+              last_result = JSON.parse(response.body)
+            else
+              last_result = {"error" => "no data returned"}
+            end
+            return_status = "FAILED[#{response.code}] <#{url}>: #{last_result["error"]}"
+          end
+        rescue => err
+          return_status = "FAILED[#{response.code}] <#{url}>: Could not parse response: #{err.message}"
+        end
+        if return_status
+          if response and response.code == '503'
+            Logger.warn("Collector temporarily unavailable. Continuing.")
+          else
+            Logger.error("#{return_status}")
+          end
+        end
+
+        return_status.nil?
+      end
+
+    end
+  end
+end

data/lib/newrelic_platform_binding/context.rb

@@ -0,0 +1,49 @@
+module NewRelic
+  module Binding
+    class Context
+      AGGREGATION_LIMIT = 20
+      attr_reader :components, :license_key
+      attr_accessor :version, :host, :pid
+
+      def initialize(license_key)
+        @version = nil
+        @host = nil
+        @request = Request.new(self)
+        @pid = nil
+        @license_key = license_key
+        @components = []
+        @aggregation_start = Time.now
+      end
+
+      def create_component(name, guid)
+        component = Component.new(name, guid)
+        @components.push(component)
+        return component
+      end
+
+      def get_request()
+        if past_aggregation_limit?
+          @components.each do |component|
+            component.last_delivered_at = nil
+          end
+          @request = Request.new(self)
+        elsif @request.delivered?
+          @request = Request.new(self)
+        else
+          @request
+        end
+      end
+
+      def last_request_delivered_at=(delivered_at)
+        @aggregation_start = delivered_at
+      end
+
+    private
+      def past_aggregation_limit?
+        @aggregation_start < Time.now - AGGREGATION_LIMIT * 60
+      end
+
+    end
+  end
+end
+

data/lib/newrelic_platform_binding/logger.rb

@@ -0,0 +1,40 @@
+module NewRelic
+  require 'time'
+  require 'logger'
+
+  class Logger
+    @log = ::Logger.new(STDOUT)
+    @log.level = ::Logger::WARN
+    @log.formatter = proc { |severity, datetime, progname, msg| "[#{Time.iso8601(Time.now.utc.iso8601).to_s}] #{severity}: #{msg}\n" }
+    class << self
+      def log_level=(level)
+        @log.level = level
+      end
+
+      def fatal(message)
+        @log.fatal(message)
+      end
+
+      def error(message)
+        @log.error(message)
+      end
+
+      def warn(message)
+        @log.warn(message)
+      end
+
+      def info(message)
+        @log.info(message)
+      end
+
+      def debug(message)
+        @log.debug(message)
+      end
+
+      def log_metrics=(value)
+        @log_metrics = value
+      end
+
+    end
+  end
+end

data/lib/newrelic_platform_binding/metric.rb

@@ -0,0 +1,49 @@
+require 'set'
+module NewRelic
+  module Binding
+    class Metric
+      attr_reader :component, :name, :value, :count, :min, :max, :sum_of_squares
+
+      def initialize(component, name, input_value, options = {} )
+        value = input_value.to_f
+        @component = component
+        @name = name
+        @value = value
+        if options_has_required_keys(options)
+          @count = options[:count].to_i
+          @min = options[:min].to_f
+          @max = options[:max].to_f
+          @sum_of_squares = options[:sum_of_squares].to_f
+        else
+          Logger.warn("Metric #{@name} count, min, max, and sum_of_squares are all required if one is set, falling back to value only") unless options.size == 0
+          @count = 1
+          @min = value
+          @max = value
+          @sum_of_squares = (value * value)
+        end
+      end
+
+      def aggregate(metric)
+        @value += metric.value
+        @count += metric.count
+        @min = [@min, metric.min].min
+        @max = [@max, metric.max].max
+        @sum_of_squares += metric.sum_of_squares
+      end
+
+      def to_hash
+        {
+          name => [
+            @value, @count, @min, @max, @sum_of_squares
+          ]
+        }
+      end
+
+      private
+
+      def options_has_required_keys(options)
+        options.keys.to_set.superset?(Set.new([:count, :min, :max, :sum_of_squares]))
+      end
+    end
+  end
+end

data/lib/newrelic_platform_binding/request.rb

@@ -0,0 +1,111 @@
+require 'json'
+module NewRelic
+  module Binding
+    class Request
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+        @duration = nil
+        @metrics = {}
+        @delivered = false
+        return self
+      end
+
+      def deliver
+        metrics_hash = build_request_data_structure
+        connection = Connection.new(@context)
+        if connection.send_request(metrics_hash.to_json)
+          @delivered = true
+          delivered_at = Time.now
+          context.last_request_delivered_at = delivered_at
+          duration_warning = false
+          @context.components.each do |component|
+            if @metrics.has_key?(component.key)
+              duration_warning = true if component.duration > 600
+              component.last_delivered_at = delivered_at
+            end
+          end
+          Logger.warn("Duration of more than 10 minutes between sending data to New Relic, this will cause plugins to show up as not reporting") if duration_warning
+        end
+      end
+
+      def add_metric(component, name, value, options = {})
+        metric = find_metric(component, name)
+        new_metric =  Metric.new(self, name, value, options)
+        if metric.nil?
+          metric = new_metric
+          @metrics[component.key] ||= []
+          @metrics[component.key].push(metric)
+        else
+          metric.aggregate(new_metric)
+        end
+        return metric
+      end
+
+      def metric_count
+        count = 0
+        @metrics.each do |m|
+          count = count + m.size
+        end
+        count
+      end
+
+      def component_count
+        @metrics.size
+      end
+
+      def delivered?
+        @delivered
+      end
+    private
+      def find_metric(component, name)
+        @metrics[component.key].find { |m| m.name == name } unless @metrics[component.key].nil?
+      end
+
+      def build_request_data_structure
+        {
+          'agent' => build_agent_hash(),
+          'components' => build_components_array()
+        }
+      end
+
+      def build_agent_hash
+        agent_hash = {
+          'version' => @context.version,
+        }
+        agent_hash['host'] = @context.host unless @context.host.nil?
+        agent_hash['pid'] = @context.pid unless @context.pid.nil?
+        agent_hash
+      end
+
+      def build_components_array
+        components_array = []
+        @context.components.each do |component|
+          component_hash = {
+            'name' => component.name,
+            'guid' => component.guid,
+            'duration' => component.duration,
+            'metrics' => build_metrics_hash(component)
+          }
+          components_array.push(component_hash)
+        end
+        return components_array
+      end
+
+      def build_metrics_hash(component)
+        metrics_hash = {}
+        if @metrics.has_key?(component.key)
+          @metrics[component.key].each do |metric|
+            metrics_hash.merge!(metric.to_hash)
+          end
+        else
+          Logger.warn("Component with name \"#{component.name}\" and guid \"#{component.guid}\" had no metrics")
+        end
+        metrics_hash
+      end
+
+    end
+  end
+end
+