appsignal 1.0.7 → 1.1.0.beta.1

data/lib/appsignal/integrations/capistrano/appsignal.cap

@@ -1,6 +1,6 @@
 namespace :appsignal do
   task :deploy do
-    env = fetch(:stage, fetch(:rails_env, fetch(:rack_env, 'production')))
+    env = fetch(:rails_env, fetch(:rack_env, 'production'))
     user = ENV['USER'] || ENV['USERNAME']
     revision = fetch(:appsignal_revision, fetch(:current_revision))
     logger = fetch(:logger, Logger.new($stdout))

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -1,6 +1,8 @@
 module Appsignal
   class Hooks
     class DelayedJobPlugin < ::Delayed::Plugin
+      extend Appsignal::Hooks::Helpers
+
       callbacks do |lifecycle|
         lifecycle.around(:invoke_job) do |job, &block|
           invoke_with_instrumentation(job, block)
@@ -12,24 +14,31 @@ module Appsignal
       end
 
       def self.invoke_with_instrumentation(job, block)
-        class_and_method_name = if job.payload_object.respond_to?(:appsignal_name)
-                                  job.payload_object.appsignal_name
-                                else
-                                  job.name
-                                end
-        class_name, method_name = class_and_method_name.split('#')
+        if job.respond_to?(:payload_object)
+          # Direct Delayed Job
+          class_and_method_name = extract_value(job.payload_object, :appsignal_name, job.name)
+          class_name, method_name = class_and_method_name.split('#')
+          args = extract_value(job.payload_object, :args, {})
+          job_data = job
+        elsif job.respond_to?(:job_data)
+          # Via ActiveJob
+          class_name, method_name = job.job_data[:name].split('#')
+          args = job.job_data[:args] || {}
+          job_data = job.job_data
+        end
 
         Appsignal.monitor_transaction(
           'perform_job.delayed_job',
           :class    => class_name,
           :method   => method_name,
           :metadata => {
-            :id       => job.id.to_s,
-            :queue    => job.queue,
-            :priority => job.priority || 0,
-            :attempts => job.attempts || 0
+            :id       => extract_value(job_data, :id, nil, true),
+            :queue    => extract_value(job_data, :queue),
+            :priority => extract_value(job_data, :priority, 0),
+            :attempts => extract_value(job_data, :attempts, 0)
           },
-          :queue_start => job.created_at
+          :params      => format_args(args),
+          :queue_start => extract_value(job_data, :created_at)
         ) do
           block.call(job)
         end

data/lib/appsignal/integrations/grape.rb

@@ -0,0 +1,44 @@
+module Appsignal
+  module Grape
+    class Middleware < ::Grape::Middleware::Base
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if Appsignal.active?
+          call_with_appsignal_monitoring(env)
+        else
+          @app.call(env)
+        end
+      end
+
+      def call_with_appsignal_monitoring(env)
+        request      = ::Rack::Request.new(env)
+        transaction  = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::HTTP_REQUEST,
+          request
+        )
+        begin
+          @app.call(env)
+        rescue => error
+          transaction.set_error(error)
+          raise error
+        ensure
+          api_endpoint = env['api.endpoint']
+          if api_endpoint && options = api_endpoint.options
+            method = options[:method].first
+            klass  = options[:for]
+            action = options[:path].first
+            transaction.set_action("#{method}::#{klass}##{action}")
+          end
+          transaction.set_http_or_background_queue_start
+          transaction.set_metadata('path', request.path)
+          transaction.set_metadata('method', env['REQUEST_METHOD'])
+          Appsignal::Transaction.complete_current!
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/mongo_ruby_driver.rb

@@ -1,19 +1,16 @@
 module Appsignal
   class Hooks
     class MongoMonitorSubscriber
+
       # Called by Mongo::Monitor when query starts
       def started(event)
         transaction = Appsignal::Transaction.current
         return if transaction.nil_transaction?
         return if transaction.paused?
 
-        # Format the command
-        command = Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter
-          .format(event.command_name, event.command)
-
         # Store the query on the transaction, we need it when the event finishes
         store                   = transaction.store('mongo_driver')
-        store[event.request_id] = command
+        store[event.request_id] = Appsignal::Utils.sanitize(event.command)
 
         # Start this event
         Appsignal::Extension.start_event(transaction.transaction_index)
@@ -39,15 +36,14 @@ module Appsignal
 
         # Get the query from the transaction store
         store   = transaction.store('mongo_driver')
-        command = store.delete(event.request_id) || {}
+        command = store[event.request_id].inspect
 
         # Finish the event in the extension.
         Appsignal::Extension.finish_event(
           transaction.transaction_index,
           'query.mongodb',
-          "#{event.command_name.to_s} | #{event.database_name} | #{result}",
-          Appsignal::Utils.json_generate(command),
-          0
+          event.command_name.to_s,
+          %Q(#{event.database_name} | #{result} | #{command})
         )
       end
     end

data/lib/appsignal/integrations/railtie.rb

@@ -36,6 +36,10 @@ module Appsignal
 
         Appsignal.start
       end
+
+      rake_tasks do
+        load 'tasks/diag.rake'
+      end
     end
   end
 end

data/lib/appsignal/integrations/resque.rb

@@ -2,7 +2,7 @@ module Appsignal
   module Integrations
     module ResquePlugin
       def around_perform_resque_plugin(*args)
-        Appsignal.monitor_single_transaction(
+        Appsignal.monitor_transaction(
           'perform_job.resque',
           :class => self.to_s,
           :method => 'perform'

data/lib/appsignal/js_exception_transaction.rb

@@ -28,7 +28,7 @@ module Appsignal
         @transaction_index,
         @data['name'],
         @data['message'],
-        Appsignal::Utils.json_generate(@data['backtrace'])
+        JSON.generate(@data['backtrace'])
       )
     end
 
@@ -43,7 +43,7 @@ module Appsignal
           Appsignal::Extension.set_transaction_sample_data(
             @transaction_index,
             key.to_s,
-            Appsignal::Utils.json_generate(data)
+            JSON.generate(data)
           )
         rescue JSON::GeneratorError=>e
           Appsignal.logger.error("JSON generate error (#{e.message}) for '#{data.inspect}'")
@@ -53,7 +53,6 @@ module Appsignal
 
     def complete!
       Appsignal::Extension.finish_transaction(@transaction_index)
-      Appsignal::Extension.complete_transaction(@transaction_index)
     end
   end
 end

data/lib/appsignal/subscriber.rb

@@ -45,13 +45,12 @@ module Appsignal
       return unless transaction = Appsignal::Transaction.current
       return if transaction.nil_transaction? || transaction.paused?
 
-      title, body, body_format = Appsignal::EventFormatter.format(name, payload)
+      title, body = Appsignal::EventFormatter.format(name, payload)
       Appsignal::Extension.finish_event(
         transaction.transaction_index,
         name,
         title || BLANK,
-        body || BLANK,
-        body_format || 0
+        body || BLANK
       )
     end
   end

data/lib/appsignal/transaction.rb

@@ -113,7 +113,7 @@ module Appsignal
       Appsignal::Extension.set_transaction_sample_data(
         transaction_index,
         key.to_s,
-        Appsignal::Utils.json_generate(data)
+        JSON.generate(data)
       )
     rescue JSON::GeneratorError=>e
       Appsignal.logger.error("JSON generate error (#{e.message}) for '#{data.inspect}'")
@@ -124,7 +124,6 @@ module Appsignal
         :params       => sanitized_params,
         :environment  => sanitized_environment,
         :session_data => sanitized_session_data,
-        :metadata     => metadata,
         :tags         => sanitized_tags
       }.each do |key, data|
         set_sample_data(key, data)
@@ -142,7 +141,7 @@ module Appsignal
         transaction_index,
         error.class.name,
         error.message,
-        backtrace ? Appsignal::Utils.json_generate(backtrace) : ''
+        backtrace ? JSON.generate(backtrace) : ''
       )
     rescue JSON::GeneratorError=>e
       Appsignal.logger.error("JSON generate error (#{e.message}) for '#{backtrace.inspect}'")
@@ -213,11 +212,6 @@ module Appsignal
       Appsignal::ParamsSanitizer.sanitize(session.to_hash)
     end
 
-    def metadata
-      return unless request.env
-      request.env[:metadata]
-    end
-
     # Only keep tags if they meet the following criteria:
     # * Key is a symbol or string with less then 100 chars
     # * Value is a symbol or string with less then 100 chars

data/lib/appsignal/transmitter.rb

@@ -53,7 +53,7 @@ module Appsignal
         request['Content-Type'] = CONTENT_TYPE
         request['Content-Encoding'] = CONTENT_ENCODING
         request.body = Zlib::Deflate.deflate(
-          Appsignal::Utils.json_generate(payload),
+          JSON.generate(payload, :quirks_mode => true),
           Zlib::BEST_SPEED
         )
       end

data/lib/appsignal/utils.rb

@@ -1,61 +1,25 @@
 module Appsignal
   module Utils
-    def self.sanitize(params, only_top_level=false, key_sanitizer=nil)
+    def self.sanitize(params, only_top_level=false)
       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
+            hsh[key] = only_top_level ? '?' : sanitize(val, only_top_level)
           end
         end
       elsif params.is_a?(Array)
         if only_top_level
-          sanitize(params[0], only_top_level, key_sanitizer=nil)
+          sanitize(params[0], only_top_level)
+        elsif params.first.is_a?(String)
+          ['?']
         else
           params.map do |item|
-            sanitize(item, only_top_level, key_sanitizer=nil)
-          end.uniq
+            sanitize(item, only_top_level)
+          end
         end
       else
         '?'
       end
     end
-
-    def self.sanitize_key(key, sanitizer)
-      case sanitizer
-      when :mongodb then key.to_s.gsub(/(\..+)/, '.?')
-      else key
-      end
-    end
-
-    def self.json_generate(body)
-      JSON.generate(jsonify(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)
-      end
-    end
-
-    def self.encode_utf8(value)
-      value.encode(
-        'utf-8'.freeze,
-        :invalid => :replace,
-        :undef   => :replace
-      )
-    end
   end
 end

data/lib/appsignal/version.rb

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

data/lib/tasks/diag.rake

@@ -0,0 +1,75 @@
+require 'appsignal'
+
+namespace :appsignal do
+  namespace :diag do
+
+    desc "Shows the AppSignal gem version"
+    task :gem_version do
+      puts "Gem version: #{Appsignal::VERSION}"
+    end
+
+    desc "Shows the agent version"
+    task :agent_version do
+      puts "Agent version: #{Appsignal::Extension.agent_version}"
+    end
+
+    desc "Attempt to start appsignal"
+    task :start_appsignal do
+      Appsignal.start
+    end
+
+    desc "Checks if config is present and shows the values"
+    task :config => :start_appsignal do
+      Appsignal.config.config_hash.each do |key, val|
+        puts "Config #{key}: #{val}"
+      end
+    end
+
+    desc "Checks if required paths are writeable"
+    task :paths_writable => :start_appsignal do
+      possible_paths = [
+        Appsignal.config.root_path,
+        Appsignal.config.log_file_path
+      ]
+
+      puts "Checking if required paths are writable:"
+      possible_paths.each do |path|
+        result = File.writable?(path) ? 'Ok' : 'Failed'
+        puts "#{path} ...#{result}"
+      end
+      puts "\n"
+    end
+
+    desc "Check if API key is valid"
+    task :check_api_key => :start_appsignal do
+      auth_check = ::Appsignal::AuthCheck.new(Appsignal.config, Appsignal.logger)
+      status, result = auth_check.perform_with_result
+      if status == '200'
+        puts "Checking API key: Ok"
+      else
+        puts "Checking API key: Failed"
+      end
+    end
+
+    desc "Check the ext installation log"
+    task :check_ext_install do
+      require 'bundler/cli'
+      require "bundler/cli/common"
+      path     = Bundler::CLI::Common.select_spec('appsignal').full_gem_path
+      log_path = "#{path.strip}/ext/install.log"
+      puts "Showing last lines of extension install log: #{log_path}"
+      puts File.read(log_path)
+      puts "\n"
+    end
+
+    task :run => [
+      "diag:gem_version",
+      "diag:agent_version",
+      "diag:start_appsignal",
+      "diag:config",
+      "diag:check_api_key",
+      "diag:paths_writable",
+      "diag:check_ext_install"
+    ]
+  end
+end

data/spec/lib/appsignal/capistrano3_spec.rb

@@ -80,29 +80,9 @@ if capistrano3_present?
               )
             end
           end
-
-          context "when stage is used instead of rack_env / rails_env" do
-            before do
-              @capistrano_config.delete(:rails_env)
-              @capistrano_config.set(:stage, 'stage_production')
-            end
-
-            it "should be instantiated with the right params" do
-              Appsignal::Config.should_receive(:new).with(
-                project_fixture_path,
-                'stage_production',
-                {:name => 'AppName'},
-                kind_of(Logger)
-              )
-            end
-          end
         end
 
-        after do
-          invoke('appsignal:deploy')
-          @capistrano_config.delete(:stage)
-          @capistrano_config.delete(:rack_env)
-        end
+        after { invoke('appsignal:deploy') }
       end
 
       context "send marker" do

data/spec/lib/appsignal/config_spec.rb

@@ -98,18 +98,6 @@ describe Appsignal::Config do
         ENV['APPSIGNAL_HTTP_PROXY'].should                   == 'http://localhost'
         ENV['APPSIGNAL_IGNORE_ACTIONS'].should               == 'action1,action2'
         ENV['APPSIGNAL_RUNNING_IN_CONTAINER'].should         == 'false'
-        ENV['APPSIGNAL_WORKING_DIR_PATH'].should             be_nil
-      end
-
-      context "if working_dir_path is set" do
-        before do
-          subject.config_hash[:working_dir_path] = '/tmp/appsignal2'
-          subject.write_to_environment
-        end
-
-        it "should write the current config to env vars" do
-          ENV['APPSIGNAL_WORKING_DIR_PATH'].should == '/tmp/appsignal2'
-        end
       end
     end