appsignal 0.4.0

data/lib/appsignal/auth_check.rb

@@ -0,0 +1,19 @@
+module Appsignal
+  class AuthCheck
+    delegate :uri, :to => :transmitter
+    attr_reader :config
+    attr_accessor :transmitter
+    ACTION = 'auth'
+
+    def initialize(environment)
+      @config = Appsignal::Config.new(Rails.root, environment).load
+    end
+
+    def perform
+      self.transmitter = Appsignal::Transmitter.new(
+        @config[:endpoint], ACTION, @config[:api_key]
+      )
+      transmitter.transmit({})
+    end
+  end
+end

data/lib/appsignal/capistrano.rb

@@ -0,0 +1,41 @@
+require 'capistrano'
+require 'rails'
+require 'appsignal/version'
+require 'appsignal/config'
+require 'appsignal/transmitter'
+require 'appsignal/marker'
+
+module Appsignal
+  class Capistrano
+    def self.tasks(config)
+      config.load do
+        after "deploy", "appsignal:deploy"
+        after "deploy:migrations", "appsignal:deploy"
+
+        namespace :appsignal do
+          task :deploy do
+            rails_env = fetch(:rails_env, 'production')
+            user = ENV['USER'] || ENV['USERNAME']
+
+            marker_data = {
+              :revision => current_revision,
+              :repository => repository,
+              :user => user
+            }
+
+            marker = Marker.new(marker_data, ENV['PWD'], rails_env, logger)
+            if config.dry_run
+              logger.info "Dry run: Deploy marker not actually sent."
+            else
+              marker.transmit
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  Appsignal::Capistrano.tasks(Capistrano::Configuration.instance)
+end

data/lib/appsignal/cli.rb

@@ -0,0 +1,118 @@
+require 'optparse'
+require 'logger'
+require 'yaml'
+require 'rails'
+require 'appsignal/version'
+require 'appsignal/config'
+require 'appsignal/marker'
+require 'appsignal/transmitter'
+
+module Appsignal
+  class CLI
+    AVAILABLE_COMMANDS = %w( notify_of_deploy )
+
+    class << self
+      def run(argv=ARGV)
+        unless File.exists?(File.join(ENV['PWD'], 'config/appsignal.yml'))
+          puts 'No config file present at config/appsignal.yml'
+          puts 'Log in to https://appsignal.com to get instructions on how to generate the config file.'
+          exit(1)
+        end
+        options = {}
+        global = global_option_parser(options)
+        commands = command_option_parser(options)
+
+        global.order!(argv)
+        command = argv.shift
+        if command then
+          if AVAILABLE_COMMANDS.include?(command) then
+            commands[command].parse!(argv)
+            case options[:command]
+            when :notify_of_deploy
+              notify_of_deploy(options)
+            end
+          else
+            puts "Command '#{command}' does not exist, run appsignal -h to see the help"
+            exit(1)
+          end
+        else
+          # Print help
+          puts global
+          exit(0)
+        end
+      end
+
+      def logger
+        Logger.new($stdout)
+      end
+
+      def global_option_parser(options)
+        OptionParser.new do |o|
+          o.banner = %Q{Usage: appsignal <command> [options]}
+
+          o.on '-v', '--version', "Print version and exit" do |arg|
+            puts "Appsignal #{Appsignal::VERSION}"
+            exit(0)
+          end
+
+          o.on '-h', '--help', "Show help and exit" do
+            puts o
+            exit(0)
+          end
+
+          o.separator ''
+          o.separator "Available commands: #{AVAILABLE_COMMANDS.join(', ')}"
+        end
+      end
+
+      def command_option_parser(options)
+        {
+          'notify_of_deploy' => OptionParser.new do |o|
+            o.banner = %Q{Usage: appsignal notify_of_deploy [options] }
+            options[:command] = :notify_of_deploy
+
+            o.on '--revision=<revision>', "The revision you're deploying" do |arg|
+              options[:revision] = arg
+            end
+
+            o.on '--repository=<repository>', "The location of the main code repository" do |arg|
+              options[:repository] = arg
+            end
+
+            o.on '--user=<user>', "The name of the user that's deploying" do |arg|
+              options[:user] = arg
+            end
+
+            o.on '--environment=<rails_env>', "The environment you're deploying to" do |arg|
+              options[:environment] = arg
+            end
+          end
+        }
+      end
+
+      def notify_of_deploy(options)
+        validate_required_options([:revision, :repository, :user, :environment], options)
+        Appsignal::Marker.new(
+          {
+            :revision => options[:revision],
+            :repository => options[:repository],
+            :user => options[:user]
+          },
+          ENV['PWD'],
+          options[:environment],
+          logger
+        ).transmit
+      end
+
+      def validate_required_options(required_options, options)
+        missing = required_options.select do |required_option|
+          options[required_option].blank?
+        end
+        if missing.any?
+          puts "Missing options: #{missing.join(', ')}"
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/config.rb

@@ -0,0 +1,30 @@
+module Appsignal
+  class Config
+    attr_accessor :root_path, :rails_env
+
+    def initialize(root_path, rails_env, logger=Appsignal.logger)
+      @root_path = root_path
+      @rails_env = rails_env
+      @logger = logger
+    end
+
+    def load
+      file = File.join(@root_path, 'config/appsignal.yml')
+      unless File.exists?(file)
+        @logger.error "config not found at: #{file}"
+        return
+      end
+
+      config = YAML.load_file(file)[@rails_env]
+      unless config
+        @logger.error "config for '#{@rails_env}' not found"
+        return
+      end
+
+      config = {:ignore_exceptions => [],
+        :endpoint => 'https://push.appsignal.com/1',
+        :slow_request_threshold => 200
+      }.merge(config.symbolize_keys)
+    end
+  end
+end

data/lib/appsignal/exception_notification.rb

@@ -0,0 +1,25 @@
+module Appsignal
+  class MissingController
+    def method_missing(*args, &block)
+    end
+  end
+
+  class ExceptionNotification
+    attr_reader :env, :exception, :kontroller, :request, :backtrace
+
+    def initialize(env, exception)
+      @exception  = exception
+      @backtrace  = Rails.respond_to?(:backtrace_cleaner) ?
+          Rails.backtrace_cleaner.send(:filter, exception.backtrace) :
+          exception.backtrace
+    end
+
+    def name
+      @exception.class.name
+    end
+
+    def message
+      @exception.message
+    end
+  end
+end

data/lib/appsignal/marker.rb

@@ -0,0 +1,35 @@
+module Appsignal
+  class Marker
+    attr_reader :marker_data, :config, :logger
+    ACTION = 'markers'
+
+    def initialize(marker_data, root_path, rails_env, logger)
+      @marker_data = marker_data
+      @config = Appsignal::Config.new(root_path, rails_env, logger).load
+      @logger = logger
+    end
+
+    def transmit
+      begin
+        transmitter = Transmitter.new(
+          @config[:endpoint], ACTION, @config[:api_key]
+        )
+        @logger.info "Notifying Appsignal of deploy..."
+        result = transmitter.transmit(marker_data)
+        if result == '200'
+          @logger.info "Appsignal has been notified of this deploy!"
+        else
+          raise "#{result} at #{transmitter.uri}"
+        end
+      rescue Exception => e
+        message = "Something went wrong while trying to notify Appsignal: #{e}"
+        if @logger.respond_to?(:important)
+          # This is a Capistrano logger
+          @logger.important message
+        else
+          @logger.error message
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/middleware.rb

@@ -0,0 +1,30 @@
+require 'action_dispatch'
+
+module Appsignal
+  class Middleware
+    def initialize(app, options = {})
+      @app, @options = app, options
+    end
+
+    def call(env)
+      Appsignal::Transaction.create(env['action_dispatch.request_id'], env)
+      @app.call(env)
+    rescue Exception => exception
+      unless in_ignored_exceptions?(exception)
+        Appsignal::Transaction.current.add_exception(
+          Appsignal::ExceptionNotification.new(env, exception)
+        )
+      end
+      raise exception
+    ensure
+      Appsignal::Transaction.current.complete!
+    end
+
+    private
+
+    def in_ignored_exceptions?(exception)
+      Array.wrap(Appsignal.config[:ignore_exceptions]).
+        include?(exception.class.name)
+    end
+  end
+end

data/lib/appsignal/railtie.rb

@@ -0,0 +1,19 @@
+module Appsignal
+  class Railtie < Rails::Railtie
+    initializer "appsignal.configure_rails_initialization" do |app|
+      if Appsignal.active?
+        app.middleware.insert_before ActionDispatch::RemoteIp, Appsignal::Middleware
+
+        Appsignal.subscriber = ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
+          if Appsignal::Transaction.current
+            event = ActiveSupport::Notifications::Event.new(*args)
+            if event.name == 'process_action.action_controller'
+              Appsignal::Transaction.current.set_process_action_event(event)
+            end
+            Appsignal::Transaction.current.add_event(event)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/transaction.rb

@@ -0,0 +1,77 @@
+require 'socket'
+require 'appsignal/transaction/transaction_formatter'
+
+module Appsignal
+  class Transaction
+    def self.create(key, env)
+      Thread.current[:appsignal_transaction_id] = key
+      Appsignal.transactions[key] = Appsignal::Transaction.new(key, env)
+    end
+
+    def self.current
+      Appsignal.transactions[Thread.current[:appsignal_transaction_id]]
+    end
+
+    attr_reader :id, :events, :process_action_event, :action, :exception, :env
+
+    def initialize(id, env)
+      @id = id
+      @events = []
+      @process_action_event = nil
+      @exception = nil
+      @env = env
+    end
+
+    def request
+      ActionDispatch::Request.new(@env)
+    end
+
+    def set_process_action_event(event)
+      @process_action_event = event
+      if @process_action_event && @process_action_event.payload
+        @action = "#{process_action_event.payload[:controller]}#"\
+                  "#{process_action_event.payload[:action]}"
+      end
+    end
+
+    def add_event(event)
+      @events << event
+    end
+
+    def add_exception(ex)
+      @exception = ex
+    end
+
+    def exception?
+      !!exception
+    end
+
+    def slow_request?
+      return false unless process_action_event && process_action_event.payload
+      Appsignal.config[:slow_request_threshold] <= process_action_event.duration
+    end
+
+    def clear_payload_and_events!
+      @process_action_event.payload.clear
+      @events.clear
+    end
+
+    def to_hash
+      if exception?
+        TransactionFormatter.faulty(self)
+      elsif slow_request?
+        TransactionFormatter.slow(self)
+      else
+        TransactionFormatter.regular(self)
+      end.to_hash
+    end
+
+    def complete!
+      Thread.current[:appsignal_transaction_id] = nil
+      current_transaction = Appsignal.transactions.delete(@id)
+      if process_action_event || exception?
+        Appsignal.agent.add_to_queue(current_transaction)
+      end
+    end
+  end
+end

data/lib/appsignal/transaction/faulty_request_formatter.rb

@@ -0,0 +1,30 @@
+module Appsignal
+  class TransactionFormatter
+    class FaultyRequestFormatter < Appsignal::TransactionFormatter
+
+      def to_hash
+        super.merge :exception => formatted_exception
+      end
+
+      protected
+
+      def_delegators :exception, :backtrace, :name, :message
+
+      def formatted_exception
+        {
+          :backtrace => backtrace,
+          :exception => name,
+          :message => message
+        }
+      end
+
+      def basic_process_action_event
+        super.merge(
+          :environment => filtered_environment,
+          :session_data => request.session
+        )
+      end
+
+    end
+  end
+end

data/lib/appsignal/transaction/params_sanitizer.rb

@@ -0,0 +1,36 @@
+module Appsignal
+  class ParamsSanitizer
+    class << self
+      def sanitize(params)
+        sanitize_hash(params)
+      end
+
+      protected
+
+      def sanitize_hash(hash)
+        out = {}
+        hash.each_pair do |key, value|
+          out[key] = sanitize_value(value)
+        end
+        out
+      end
+
+      def sanitize_array(array)
+        array.map { |value| sanitize_value(value) }
+      end
+
+      def sanitize_value(value)
+        case value
+        when Hash
+          sanitize_hash(value)
+        when Array
+          sanitize_array(value)
+        when String
+          value
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end