scout_apm 0.1.6 → 0.1.7

data/lib/scout_apm/layaway_file.rb

@@ -69,4 +69,4 @@ class ScoutApm::LayawayFile
   rescue EOFError
     contents
   end
-end
+end

data/lib/scout_apm/metric_meta.rb

@@ -11,24 +11,24 @@ class ScoutApm::MetricMeta
   attr_accessor :scope
   attr_accessor :client_id
   attr_accessor :desc, :extra
-  
+
   # To avoid conflicts with different JSON libaries
   def to_json(*a)
      %Q[{"metric_id":#{metric_id || 'null'},"metric_name":#{metric_name.to_json},"scope":#{scope.to_json || 'null'}}]
   end
-  
+
   def ==(o)
     self.eql?(o)
   end
-  
+
   def hash
-     h = metric_name.downcase.hash
-     h ^= scope.downcase.hash unless scope.nil?
-     h ^= desc.downcase.hash unless desc.nil?
-     h
-   end
+    h = metric_name.downcase.hash
+    h ^= scope.downcase.hash unless scope.nil?
+    h ^= desc.downcase.hash unless desc.nil?
+    h
+  end
 
   def eql?(o)
    self.class == o.class && metric_name.downcase.eql?(o.metric_name.downcase) && scope == o.scope && client_id == o.client_id && desc == o.desc
   end
-end # class MetricMeta
+end # class MetricMeta

data/lib/scout_apm/metric_stats.rb

@@ -1,4 +1,4 @@
-# Stats that are associated with each instrumented method. 
+# Stats that are associated with each instrumented method.
 class ScoutApm::MetricStats
   attr_accessor :call_count
   attr_accessor :min_call_time
@@ -6,7 +6,7 @@ class ScoutApm::MetricStats
   attr_accessor :total_call_time
   attr_accessor :total_exclusive_time
   attr_accessor :sum_of_squares
-  
+
   def initialize(scoped = false)
     @scoped = scoped
     self.call_count = 0
@@ -16,20 +16,20 @@ class ScoutApm::MetricStats
     self.max_call_time = 0.0
     self.sum_of_squares = 0.0
   end
-  
+
   def update!(call_time,exclusive_time)
     # If this metric is scoped inside another, use exclusive time for min/max and sum_of_squares. Non-scoped metrics
     # (like controller actions) track the total call time.
     t = (@scoped ? exclusive_time : call_time)
     self.min_call_time = t if self.call_count == 0 or t < min_call_time
-    self.max_call_time = t if self.call_count == 0 or t > max_call_time   
+    self.max_call_time = t if self.call_count == 0 or t > max_call_time
     self.call_count +=1
     self.total_call_time += call_time
     self.total_exclusive_time += exclusive_time
     self.sum_of_squares += (t * t)
     self
   end
-  
+
   # combines data from another MetricStats object
   def combine!(other)
     self.call_count += other.call_count
@@ -40,10 +40,10 @@ class ScoutApm::MetricStats
     self.sum_of_squares += other.sum_of_squares
     self
   end
-  
-  # To avoid conflicts with different JSON libaries handle JSON ourselves. 
+
+  # To avoid conflicts with different JSON libaries handle JSON ourselves.
   # Time-based metrics are converted to milliseconds from seconds.
   def to_json(*a)
      %Q[{"total_exclusive_time":#{total_exclusive_time*1000},"min_call_time":#{min_call_time*1000},"call_count":#{call_count},"sum_of_squares":#{sum_of_squares*1000},"total_call_time":#{total_call_time*1000},"max_call_time":#{max_call_time*1000}}]
   end
-end # class MetricStats
+end # class MetricStats

data/lib/scout_apm/reporter.rb

@@ -0,0 +1,83 @@
+module ScoutApm
+  class Reporter
+    CA_FILE     = File.join( File.dirname(__FILE__), *%w[.. .. data cacert.pem] )
+    VERIFY_MODE = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+
+    attr_reader :config
+    attr_reader :logger
+    attr_reader :type
+
+    def initialize(config=Agent.instance.config, logger=Agent.instance.logger, type: :checkin)
+      @config = config
+      @logger = logger
+      @type = type
+    end
+
+    # TODO: Parse & return a real response object, not the HTTP Response object
+    def report(payload)
+      post(uri, payload)
+    end
+
+    def uri
+      case type
+      when :checkin
+        URI.parse("#{config.value('host')}/apps/checkin.scout?key=#{config.value('key')}&name=#{CGI.escape(Environment.instance.application_name)}")
+      when :app_server_load
+        URI.parse("#{config.value('host')}/apps/app_server_load.scout?key=#{config.value('key')}&name=#{CGI.escape(Environment.instance.application_name)}")
+      end.tap{|u| logger.debug("Posting to #{u.to_s}")}
+    end
+
+    private
+
+    def post(uri, body, headers = Hash.new)
+      response = nil
+      request(uri) do |connection|
+        post = Net::HTTP::Post.new( uri.path +
+                                    (uri.query ? ('?' + uri.query) : ''),
+                                    default_http_headers.merge(headers) )
+        post.body = body
+        response=connection.request(post)
+      end
+      response
+    end
+
+    def request(uri, &connector)
+      response           = nil
+      response           = http(uri).start(&connector)
+      logger.debug "got response: #{response.inspect}"
+      case response
+      when Net::HTTPSuccess, Net::HTTPNotModified
+        logger.debug "/#{type} OK"
+      when Net::HTTPBadRequest
+        logger.warn "/#{type} FAILED: The Account Key [#{config.value('key')}] is invalid."
+      else
+        logger.debug "/#{type} FAILED: #{response.inspect}"
+      end
+    rescue Exception
+      logger.debug "Exception sending request to server: #{$!.message}\n#{$!.backtrace}"
+    ensure
+      response
+    end
+
+    # Headers passed up with all API requests.
+    def default_http_headers
+      { "Agent-Hostname" => ScoutApm::Environment.instance.hostname,
+        "Content-Type"   => "application/octet-stream"
+      }
+    end
+
+    # Take care of the http proxy, if specified in config.
+    # Given a blank string, the proxy_uri URI instance's host/port/user/pass will be nil.
+    # Net::HTTP::Proxy returns a regular Net::HTTP class if the first argument (host) is nil.
+    def http(url)
+      proxy_uri = URI.parse(config.value('proxy').to_s)
+      http = Net::HTTP::Proxy(proxy_uri.host,proxy_uri.port,proxy_uri.user,proxy_uri.password).new(url.host, url.port)
+      if url.is_a?(URI::HTTPS)
+        http.use_ssl = true
+        http.ca_file = CA_FILE
+        http.verify_mode = VERIFY_MODE
+      end
+      http
+    end
+  end
+end

data/lib/scout_apm/serializers/app_server_load_serializer.rb

@@ -0,0 +1,15 @@
+# Serialize & deserialize commands from the APM server to the instrumented app
+
+module ScoutApm
+  module Serializers
+    class AppServerLoadSerializer
+      def self.serialize(data)
+        Marshal.dump(data)
+      end
+
+      def self.deserialize(data)
+        Marshal.load(data)
+      end
+    end
+  end
+end

data/lib/scout_apm/serializers/directive_serializer.rb

@@ -0,0 +1,15 @@
+# Serialize & deserialize commands from the APM server to the instrumented app
+
+module ScoutApm
+  module Serializers
+    class DirectiveSerializer
+      def self.serialize(data)
+        Marshal.dump(data)
+      end
+
+      def self.deserialize(data)
+        Marshal.load(data)
+      end
+    end
+  end
+end

data/lib/scout_apm/serializers/payload_serializer.rb

@@ -0,0 +1,14 @@
+# Serialize & deserialize data from the instrumented app up to the APM server
+module ScoutApm
+  module Serializers
+    class PayloadSerializer
+      def self.serialize(metrics, slow_transactions)
+        Marshal.dump(:metrics => metrics, :slow_transactions => slow_transactions)
+      end
+
+      def self.deserialize(data)
+        Marshal.load(data)
+      end
+    end
+  end
+end

data/lib/scout_apm/server_integrations/null.rb

@@ -0,0 +1,30 @@
+# A lack of app server to integrate with.
+# Null Object pattern
+
+module ScoutApm
+  module ServerIntegrations
+    class Null
+      attr_reader :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def name
+        :null
+      end
+
+      def present?
+        true
+      end
+
+      def install
+        # Nothing to do.
+      end
+
+      def forking?
+        false
+      end
+    end
+  end
+end

data/lib/scout_apm/server_integrations/passenger.rb

@@ -0,0 +1,35 @@
+module ScoutApm
+  module ServerIntegrations
+    class Passenger
+      attr_reader :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def name
+        :passenger
+      end
+
+      def forking?; true; end
+
+      def present?
+        (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::PhusionPassenger)
+      end
+
+      def install
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          logger.debug "Passenger is starting a worker process. Starting worker thread."
+          ScoutApm::Agent.instance.start_background_worker
+        end
+
+        # The agent's at_exit hook doesn't run when a Passenger process stops.
+        # This does run when a process stops.
+        PhusionPassenger.on_event(:stopping_worker_process) do
+          logger.debug "Passenger is stopping a worker process, shutting down the agent."
+          ScoutApm::Agent.instance.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/server_integrations/puma.rb

@@ -0,0 +1,30 @@
+module ScoutApm
+  module ServerIntegrations
+    class Puma
+      attr_reader :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def name
+        :puma
+      end
+
+      def forking?; true; end
+
+      def present?
+        defined?(::Puma) && File.basename($0) == 'puma'
+      end
+
+      def install
+        Puma.cli_config.options[:before_worker_boot] << Proc.new do
+          logger.debug "Installing Puma worker loop."
+          ScoutApm::Agent.instance.start_background_worker
+        end
+      rescue
+        logger.warn "Unable to install Puma worker loop: #{$!.message}"
+      end
+    end
+  end
+end

data/lib/scout_apm/server_integrations/rainbows.rb

@@ -0,0 +1,36 @@
+module ScoutApm
+  module ServerIntegrations
+    class Rainbows
+      attr_reader :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def name
+        :rainbows
+      end
+
+      def forking?; true; end
+
+      def present?
+        if defined?(::Rainbows) && defined?(::Rainbows::HttpServer)
+          ObjectSpace.each_object(::Rainbows::HttpServer) { |x| return true }
+          false
+        end
+      end
+
+      def install
+        logger.debug "Installing Rainbows worker loop."
+
+        Rainbows::HttpServer.class_eval do
+          old = instance_method(:worker_loop)
+          define_method(:worker_loop) do |worker|
+            ScoutApm::Agent.instance.start_background_worker
+            old.bind(self).call(worker)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/server_integrations/thin.rb

@@ -0,0 +1,41 @@
+module ScoutApm
+  module ServerIntegrations
+    class Thin
+      attr_reader :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def name
+        :thin
+      end
+
+      def forking?; false; end
+
+      def present?
+        found_thin = false
+
+        # This code block detects when thin is run as:
+        # `thin start`
+        if defined?(::Thin) && defined?(::Thin::Server)
+          # Ensure Thin is actually initialized. It could just be required and not running.
+          ObjectSpace.each_object(::Thin::Server) { |x| found_thin = true }
+        end
+
+        # This code block detects when thin is run as:
+        # `rails server`
+        if defined?(::Rails::Server)
+          ObjectSpace.each_object(::Rails::Server) { |x| found_thin ||= (x.instance_variable_get(:@_server).to_s == "Rack::Handler::Thin") }
+        end
+
+        found_thin
+      end
+
+      # TODO: What does it mean to install on a non-forking env?
+      def install
+      end
+    end
+  end
+end
+

data/lib/scout_apm/server_integrations/unicorn.rb

@@ -0,0 +1,35 @@
+module ScoutApm
+  module ServerIntegrations
+    class Unicorn
+      attr_reader :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def name
+        :unicorn
+      end
+
+      def forking?; true; end
+
+      def present?
+        if defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
+          # Ensure Unicorn is actually initialized. It could just be required and not running.
+          ObjectSpace.each_object(::Unicorn::HttpServer) { |x| return true }
+          false
+        end
+      end
+
+      def install
+        ::Unicorn::HttpServer.class_eval do
+          old = instance_method(:worker_loop)
+          define_method(:worker_loop) do |worker|
+            ScoutApm::Agent.instance.start_background_worker
+            old.bind(self).call(worker)
+          end
+        end
+      end
+    end
+  end
+end