appsignal 1.2.5 → 1.3.0.beta.1

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -2,7 +2,28 @@ require 'rack'
 
 module Appsignal
   module Rack
+    # Stub old middleware. Prevents Sinatra middleware being loaded twice.
+    # This can happen when users use the old method of including
+    # `use Appsignal::Rack::SinatraInstrumentation` in their modular Sinatra
+    # applications. This is no longer needed. Instead Appsignal now includes
+    # `use Appsignal::Rack::SinatraBaseInstrumentation` automatically.
     class SinatraInstrumentation
+      def initialize(app, options = {})
+        @app, @options = app, options
+        Appsignal.logger.warn 'Please remove Appsignal::Rack::SinatraInstrumentation '\
+          'from your Sinatra::Base class. This is no longer needed.'
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def settings
+        @app.settings
+      end
+    end
+
+    class SinatraBaseInstrumentation
       attr_reader :raise_errors_on
 
       def initialize(app, options = {})
@@ -51,11 +72,13 @@ module Appsignal
         end
       end
 
-
       def action_name(env)
         if @options.fetch(:mounted_at, nil)
           method, route = env['sinatra.route'].split(" ")
-          "#{method} #{@options.fetch(:mounted_at, nil)}#{route}"
+          "#{method} #{@options[:mounted_at]}#{route}"
+        elsif env['SCRIPT_NAME']
+          method, route = env['sinatra.route'].split(" ")
+          "#{method} #{env['SCRIPT_NAME']}#{route}"
         else
           env['sinatra.route']
         end

data/lib/appsignal/transaction.rb

@@ -181,15 +181,32 @@ module Appsignal
       @ext.start_event
     end
 
-    def finish_event(name, title, body, body_format)
+    def finish_event(name, title, body, body_format=Appsignal::EventFormatter::DEFAULT)
       @ext.finish_event(
         name,
         title || BLANK,
         body || BLANK,
-        body_format || 0
+        body_format || Appsignal::EventFormatter::DEFAULT
       )
     end
 
+    def record_event(name, title, body, duration, body_format=Appsignal::EventFormatter::DEFAULT)
+      @ext.record_event(
+        name,
+        title || BLANK,
+        body || BLANK,
+        duration,
+        body_format || Appsignal::EventFormatter::DEFAULT
+      )
+    end
+
+    def instrument(name, title=nil, body=nil, body_format=Appsignal::EventFormatter::DEFAULT)
+      start_event
+      r = yield
+      finish_event(name, title, body, body_format)
+      r
+    end
+
     class GenericRequest
       attr_reader :env
 
@@ -231,18 +248,22 @@ module Appsignal
     def sanitized_params
       return unless Appsignal.config[:send_params]
       return unless request.respond_to?(options[:params_method])
-      begin
-        return unless params = request.send(options[:params_method])
-      rescue Exception => ex
-        # Getting params from the request has been know to fail.
-        Appsignal.logger.debug "Exception while getting params: #{ex}"
-        return
-      end
-      if params.is_a?(Hash)
-        Appsignal::ParamsSanitizer.sanitize(params)
-      elsif params.is_a?(Array)
-        params
+
+      params =
+        begin
+          request.send options[:params_method]
+        rescue Exception => ex
+          # Getting params from the request has been know to fail.
+          Appsignal.logger.debug "Exception while getting params: #{ex}"
+          nil
+        end
+      return unless params
+
+      options = {}
+      if Appsignal.config[:filter_parameters]
+        options[:filter_parameters] = Appsignal.config[:filter_parameters]
       end
+      Appsignal::Utils::ParamsSanitizer.sanitize params, options
     end
 
     def sanitized_environment
@@ -257,7 +278,7 @@ module Appsignal
     def sanitized_session_data
       return if Appsignal.config[:skip_session_data] || !request.respond_to?(:session)
       return unless session = request.session
-      Appsignal::ParamsSanitizer.sanitize(session.to_hash)
+      Appsignal::Utils::ParamsSanitizer.sanitize(session.to_hash)
     end
 
     def metadata
@@ -272,7 +293,7 @@ module Appsignal
     def sanitized_tags
       @tags.select do |k, v|
         (k.is_a?(Symbol) || k.is_a?(String) && k.length <= 100) &&
-        (((v.is_a?(Symbol) || v.is_a?(String)) && v.length <= 100) || (v.is_a?(Integer)))
+          (((v.is_a?(Symbol) || v.is_a?(String)) && v.length <= 100) || (v.is_a?(Integer)))
       end
     end
 
@@ -290,6 +311,11 @@ module Appsignal
       def method_missing(m, *args, &block)
       end
 
+      # Instrument should still yield
+      def instrument(*args)
+        yield
+      end
+
       def nil_transaction?
         true
       end

data/lib/appsignal/transmitter.rb

@@ -35,7 +35,7 @@ module Appsignal
           :api_key => config[:push_api_key],
           :name => config[:name],
           :environment => config.env,
-          :hostname => Socket.gethostname,
+          :hostname => config[:hostname],
           :gem_version => Appsignal::VERSION
         })
       end

data/lib/appsignal/utils.rb

@@ -1,61 +1,56 @@
+require 'appsignal/utils/params_sanitizer'
+require 'appsignal/utils/query_params_sanitizer'
+
 module Appsignal
   module Utils
-    def self.sanitize(params, only_top_level=false, key_sanitizer=nil)
-      if params.is_a?(Hash)
-        {}.tap do |hsh|
-          params.each do |key, val|
-            hsh[self.sanitize_key(key, key_sanitizer)] = if only_top_level
-              '?'
-            else
-              sanitize(val, only_top_level, key_sanitizer=nil)
-            end
-          end
-        end
-      elsif params.is_a?(Array)
-        if only_top_level
-          sanitize(params[0], only_top_level, key_sanitizer=nil)
-        else
-          params.map do |item|
-            sanitize(item, only_top_level, key_sanitizer=nil)
-          end.uniq
-        end
-      else
-        '?'
-      end
-    end
+    module ClassMethods
+      extend Gem::Deprecate
 
-    def self.sanitize_key(key, sanitizer)
-      case sanitizer
-      when :mongodb then key.to_s.gsub(/(\..+)/, '.?')
-      else key
+      def sanitize(params, only_top_level = false, key_sanitizer = nil)
+        QueryParamsSanitizer.sanitize(params, only_top_level, key_sanitizer)
       end
+
+      deprecate :sanitize, "AppSignal::Utils::QueryParamsSanitizer.sanitize", 2016, 9
     end
+    extend ClassMethods
 
     def self.json_generate(body)
-      JSON.generate(jsonify(body))
+      JSON.generate(body)
     end
 
-    def self.jsonify(value)
-      case value
-      when String
-        encode_utf8(value)
-      when Numeric, NilClass, TrueClass, FalseClass
-        value
-      when Hash
-        Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
-      when Array
-        value.map { |v| jsonify(v) }
-      else
-        jsonify(value.to_s)
+    class JSON
+      module ClassMethods
+        def generate(body)
+          ::JSON.generate(jsonify(body))
+        end
+
+        private
+
+        def jsonify(value)
+          case value
+          when String
+            encode_utf8(value)
+          when Numeric, NilClass, TrueClass, FalseClass
+            value
+          when Hash
+            Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
+          when Array
+            value.map { |v| jsonify(v) }
+          else
+            jsonify(value.to_s)
+          end
+        end
+
+        def encode_utf8(value)
+          value.encode(
+            'utf-8'.freeze,
+            :invalid => :replace,
+            :undef   => :replace
+          )
+        end
       end
-    end
 
-    def self.encode_utf8(value)
-      value.encode(
-        'utf-8'.freeze,
-        :invalid => :replace,
-        :undef   => :replace
-      )
+      extend ClassMethods
     end
   end
 end

data/lib/appsignal/utils/params_sanitizer.rb

@@ -0,0 +1,58 @@
+module Appsignal
+  module Utils
+    class ParamsSanitizer
+      FILTERED = '[FILTERED]'.freeze
+
+      class << self
+        def sanitize(params, options = {})
+          sanitize_value(params, options)
+        end
+
+        private
+
+        def sanitize_value(value, options = {})
+          case value
+          when Hash
+            sanitize_hash(value, options)
+          when Array
+            sanitize_array(value, options)
+          when TrueClass, FalseClass, NilClass, Fixnum, String, Symbol, Float
+            unmodified(value)
+          else
+            inspected(value)
+          end
+        end
+
+        def sanitize_hash(source, options)
+          filter_keys = options.fetch(:filter_parameters, [])
+          {}.tap do |hash|
+            source.each_pair do |key, value|
+              hash[key] =
+                if filter_keys.include?(key.to_s)
+                  FILTERED
+                else
+                  sanitize_value(value, options)
+                end
+            end
+          end
+        end
+
+        def sanitize_array(source, options)
+          [].tap do |array|
+            source.each_with_index do |item, index|
+              array[index] = sanitize_value(item, options)
+            end
+          end
+        end
+
+        def unmodified(value)
+          value
+        end
+
+        def inspected(value)
+          "#<#{value.class}>"
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/utils/query_params_sanitizer.rb

@@ -0,0 +1,54 @@
+module Appsignal
+  module Utils
+    class QueryParamsSanitizer
+      REPLACEMENT_KEY = '?'.freeze
+
+      module ClassMethods
+        def sanitize(params, only_top_level = false, key_sanitizer = nil)
+          case params
+          when Hash
+            sanitize_hash params, only_top_level, key_sanitizer
+          when Array
+            sanitize_array params, only_top_level, key_sanitizer
+          else
+            REPLACEMENT_KEY
+          end
+        end
+
+        private
+
+        def sanitize_hash(hash, only_top_level, key_sanitizer)
+          {}.tap do |h|
+            hash.each do |key, value|
+              h[sanitize_key(key, key_sanitizer)] =
+                if only_top_level
+                  REPLACEMENT_KEY
+                else
+                  sanitize(value, only_top_level, key_sanitizer)
+                end
+            end
+          end
+        end
+
+        def sanitize_array(array, only_top_level, key_sanitizer)
+          if only_top_level
+            sanitize(array[0], only_top_level, key_sanitizer)
+          else
+            array.map do |value|
+              sanitize(value, only_top_level, key_sanitizer)
+            end.uniq
+          end
+        end
+
+        def sanitize_key(key, sanitizer)
+          case sanitizer
+          when :mongodb then key.to_s.gsub(/(\..+)/, ".#{REPLACEMENT_KEY}")
+          else key
+          end
+        end
+      end
+
+      extend ClassMethods
+    end
+  end
+end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require 'yaml'
 
 module Appsignal
-  VERSION = '1.2.5'
+  VERSION = '1.3.0.beta.1'
 end

data/spec/lib/appsignal/config_spec.rb

@@ -20,6 +20,7 @@ describe Appsignal::Config do
         :debug                          => false,
         :ignore_errors                  => [],
         :ignore_actions                 => [],
+        :filter_parameters              => [],
         :instrument_net_http            => true,
         :instrument_redis               => true,
         :instrument_sequel              => true,
@@ -34,7 +35,9 @@ describe Appsignal::Config do
         :enable_allocation_tracking     => true,
         :enable_gc_instrumentation      => false,
         :running_in_container           => false,
-        :enable_host_metrics            => false
+        :enable_host_metrics            => true,
+        :enable_minutely_probes         => false,
+        :hostname                       => Socket.gethostname
       }
     end
 
@@ -102,6 +105,8 @@ describe Appsignal::Config do
         subject.config_hash[:http_proxy]     = 'http://localhost'
         subject.config_hash[:ignore_actions] = ['action1', 'action2']
         subject.config_hash[:log_path]  = '/tmp'
+        subject.config_hash[:hostname]  = 'app1.local'
+        subject.config_hash[:filter_parameters] = %w(password confirm_password)
         subject.write_to_environment
       end
 
@@ -119,9 +124,14 @@ describe Appsignal::Config do
         ENV['APPSIGNAL_LANGUAGE_INTEGRATION_VERSION'].should == Appsignal::VERSION
         ENV['APPSIGNAL_HTTP_PROXY'].should                   == 'http://localhost'
         ENV['APPSIGNAL_IGNORE_ACTIONS'].should               == 'action1,action2'
+        ENV['APPSIGNAL_FILTER_PARAMETERS'].should            == 'password,confirm_password'
+        ENV['APPSIGNAL_SEND_PARAMS'].should                  == 'true'
         ENV['APPSIGNAL_RUNNING_IN_CONTAINER'].should         == 'false'
         ENV['APPSIGNAL_WORKING_DIR_PATH'].should             be_nil
-        ENV['APPSIGNAL_ENABLE_HOST_METRICS'].should          == 'false'
+        ENV['APPSIGNAL_ENABLE_HOST_METRICS'].should          == 'true'
+        ENV['APPSIGNAL_ENABLE_MINUTELY_PROBES'].should       == 'false'
+        ENV['APPSIGNAL_HOSTNAME'].should                     == 'app1.local'
+        ENV['APPSIGNAL_PROCESS_NAME'].should                 include 'rspec'
       end
 
       context "if working_dir_path is set" do

data/spec/lib/appsignal/extension_spec.rb

@@ -48,6 +48,10 @@ describe "extension loading and operation" do
           subject.finish_event('name', 'title', 'body', 0)
         end
 
+        it "should have a record_event method" do
+          subject.record_event('name', 'title', 'body', 0, 1000)
+        end
+
         it "should have a set_error method" do
           subject.set_error('name', 'message', '[backtrace]')
         end

data/spec/lib/appsignal/hooks/net_http_spec.rb

@@ -2,54 +2,46 @@ require 'spec_helper'
 
 describe Appsignal::Hooks::NetHttpHook do
   before :all do
-    Appsignal.config = project_fixture_config
+    start_agent
   end
 
   context "with Net::HTTP instrumentation enabled" do
-    let(:events) { [] }
-    before :all do
-      Appsignal.config.config_hash[:instrument_net_http] = true
-    end
-    before do
-      ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
-      end
-    end
-    after(:all) { Appsignal.config.config_hash[:instrument_net_http] = false }
-
     its(:dependencies_present?) { should be_true }
 
-    it "should generate an event for a http request" do
+    it "should instrument a http request" do
+      Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test')
+      expect( Appsignal::Transaction.current ).to receive(:start_event)
+        .at_least(:once)
+      expect( Appsignal::Transaction.current ).to receive(:finish_event)
+        .at_least(:once)
+        .with("request.net_http", "GET http://www.google.com", nil, 0)
+
       stub_request(:any, 'http://www.google.com/')
 
       Net::HTTP.get_response(URI.parse('http://www.google.com'))
-
-      event = events.last
-      event.name.should == 'request.net_http'
-      event.payload[:protocol].should == 'http'
-      event.payload[:domain].should == 'www.google.com'
-      event.payload[:path].should == '/'
-      event.payload[:method].should == 'GET'
     end
 
-    it "should generate an event for a https request" do
+    it "should instrument a https request" do
+      Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test')
+      expect( Appsignal::Transaction.current ).to receive(:start_event)
+        .at_least(:once)
+      expect( Appsignal::Transaction.current ).to receive(:finish_event)
+        .at_least(:once)
+        .with("request.net_http", "GET https://www.google.com", nil, 0)
+
       stub_request(:any, 'https://www.google.com/')
 
       uri = URI.parse('https://www.google.com')
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
       http.get(uri.request_uri)
-
-      event = events.last
-      event.name.should == 'request.net_http'
-      event.payload[:protocol].should == 'https'
-      event.payload[:domain].should == 'www.google.com'
-      event.payload[:path].should == '/'
-      event.payload[:method].should == 'GET'
     end
   end
 
   context "with Net::HTTP instrumentation disabled" do
+    before { Appsignal.config.config_hash[:instrument_net_http] = false }
+    after { Appsignal.config.config_hash[:instrument_net_http] = true }
+
     its(:dependencies_present?) { should be_false }
   end
 end