fare 0.1.0

data/lib/fare/middleware/logging.rb

@@ -0,0 +1,46 @@
+require "logger"
+
+module Fare
+  module Middleware
+
+    # Use this to log all events and stacktraces:
+    #
+    # Usage:
+    #
+    #     use Fare::Middleware::Logging, logger: Logger.new($stdout)
+    class Logging
+
+      def initialize(app, options = {})
+        @app = app
+        @logger = options.fetch(:logger)
+      end
+
+      def call(env)
+        attrs = env.fetch(:event).attributes
+        start = Time.now
+        begin
+          @app.call(env)
+        rescue Exception => exception
+          duration = Time.now - start
+          @logger.warn("Handled event: %s" % {
+            event:          attrs,
+            result:         "failure",
+            duration:       duration,
+            error_class:    exception.class.name,
+            error_message:  exception.message,
+            backtrace:      exception.backtrace.to_a,
+          }.to_json)
+          raise
+        else
+          duration = Time.now - start
+          @logger.info("Handled event: %s" % {
+            event:     attrs,
+            result:    "success",
+            duration:  duration,
+          }.to_json)
+        end
+      end
+
+    end
+  end
+end

data/lib/fare/middleware/newrelic.rb

@@ -0,0 +1,35 @@
+require 'newrelic_rpm'
+::NewRelic::Agent.manual_start
+
+module Fare
+  module Middleware
+
+    # Add NewRelic monitoring to the subscriber.
+    # Make sure you have a newrelic.yml in your config dir.
+    #
+    # Usage:
+    #
+    #   subscriber do
+    #     setup do
+    #       require "fare/middleware/newrelic"
+    #     end
+    #     always_run do
+    #       use Fare::Middleware::NewRelic
+    #     end
+    #   end
+    class NewRelic
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      def initialize(app, options = {})
+        @app = app
+        at_exit { ::NewRelic::Agent.shutdown }
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+      add_transaction_tracer :call, :category => :task
+
+    end
+  end
+end

data/lib/fare/middleware/raven.rb

@@ -0,0 +1,47 @@
+module Fare
+  module Middleware
+
+    # Use this to send errors to Sentry:
+    #
+    # Usage:
+    #
+    #     use Fare::Middleware::Raven, dsn: "http://...", logger: logger, environment: "production"
+    class Raven
+
+      def initialize(app, options = {})
+        @app = app
+        require "raven" unless defined?(::Raven)
+        configure_sentry(options)
+      end
+
+      def call(env)
+        ::Raven.extra_context(serialize(env))
+        @app.call(env)
+      rescue Exception => exception
+        ::Raven.capture_exception(exception)
+        raise
+      ensure
+        ::Raven::Context.clear!
+      end
+
+      private
+
+      def configure_sentry(options)
+        ::Raven.configure do |config|
+          config.dsn                 = options.fetch(:dsn)
+          config.logger              = options.fetch(:logger)
+          config.environments        = [options.fetch(:environment)]
+          config.excluded_exceptions = []
+        end
+      end
+
+      # removes objects and makes normal hashes, so sentry can read the better
+      def serialize(env)
+        JSON.parse(env.to_json)
+      rescue
+        env
+      end
+
+    end
+  end
+end

data/lib/fare/publisher.rb

@@ -0,0 +1,65 @@
+module Fare
+  UnknownTopicError = Class.new(RuntimeError)
+
+  class Publisher
+
+    attr_reader :configuration, :options
+
+    def initialize(configuration, options)
+      @configuration = configuration
+      @options = options
+    end
+
+    def call
+      ensure_topic_publishable!
+      topic.publish(event.serialize)
+    end
+
+    def topic
+      Fare.topic_adapter.fetch(topic_info.fetch("arn"))
+    end
+
+    def topic_info
+      @topic_info ||= configuration.find_publishable_topic(options)
+    end
+
+    def event
+      Event.new(
+        id:      "event-#{SecureRandom.uuid}",
+        subject: subject,
+        action:  action,
+        payload: payload,
+        source:  app_name,
+        version: version,
+        sent_at: Time.now.utc,
+      )
+    end
+
+    def subject
+      options.fetch(:subject)
+    end
+
+    def action
+      options.fetch(:action)
+    end
+
+    def payload
+      options.fetch(:payload)
+    end
+
+    def version
+      topic_info.fetch("version")
+    end
+
+    def app_name
+      configuration.app_name
+    end
+
+    def ensure_topic_publishable!
+      unless topic_info
+        raise UnknownTopicError, "Topic with subject #{subject} and action #{action} not in lock file, maybe run `fare update`"
+      end
+    end
+
+  end
+end

data/lib/fare/queue_adapter.rb

@@ -0,0 +1,30 @@
+module Fare
+  class QueueAdapter
+
+    def self.fetch(*args)
+      new(*args).queue
+    end
+
+    attr_reader :environment, :name
+
+    def initialize(environment, name)
+      @environment = environment
+      @name = name
+    end
+
+    def queue
+      sqs.queues.named(queue_name)
+    rescue AWS::SQS::Errors::NonExistentQueue
+      sqs.queues.create(queue_name)
+    end
+
+    def queue_name
+      "#{environment}-#{name}"
+    end
+
+    def sqs
+      AWS::SQS.new
+    end
+
+  end
+end

data/lib/fare/rspec.rb

@@ -0,0 +1,85 @@
+begin
+  require "json_expressions"
+rescue LoadError
+  raise "Please install the gem `json_expressions` to use fare/rspec"
+end
+
+module Fare
+  module FareMatcher
+
+    def publish(subject, action, payload = nil)
+      Expectation.new(subject, action, payload)
+    end
+
+    class Expectation
+
+      attr_reader :subject, :action, :payload
+
+      def initialize(subject, action, payload)
+        @subject = subject
+        @action  = action
+        @payload = payload
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(expect_block)
+        Fare.stubbed_messages.clear
+        expect_block.call
+        !event.nil? && payload_matches?
+      end
+
+      def does_not_match?(expect_block)
+        raise ArgumentError, "Checking payload with negative expectation is not possible" if payload
+        Fare.stubbed_messages.clear
+        expect_block.call
+        event.nil?
+      end
+
+      def failure_message
+        if event.nil?
+          if Fare.stubbed_messages.size == 0
+            "There were no events published"
+          else
+            "Expected event #{event_name}, but got:\n#{Fare.stubbed_messages.list}"
+          end
+        else
+          "Payload did not match: #{payload_matcher.last_error}\nActual payload was:\n#{event.payload}"
+        end
+      end
+
+      def failure_message_when_negated
+        "Expected not to publish #{event_name}, but published it with payload: #{event.payload}"
+      end
+
+      def event_name
+        "#{subject}##{action}"
+      end
+
+      def payload_matches?
+        if payload
+          payload_matcher =~ event.payload
+        else
+          true
+        end
+      end
+
+      def event
+        Fare.stubbed_messages.get(subject, action)
+      end
+
+      def payload_matcher
+        @payload_matcher ||= JsonExpressions::Matcher.new(payload)
+      end
+
+    end
+
+  end
+
+end
+
+RSpec.configure do |config|
+  config.include Fare::FareMatcher
+end

data/lib/fare/subscriber.rb

@@ -0,0 +1,35 @@
+require "timeout"
+
+module Fare
+  class Subscriber
+    UnknownSubscriber = Class.new(ArgumentError)
+
+    attr_reader :configuration
+
+    def initialize(configuration, options = {})
+      name = (options[:name] || configuration.app_name).to_s
+      subscriber_config = configuration.fetch_subscriber(name)
+      subscriber_config.load_setup
+      @sqs_queue = configuration.fetch_subscriber_queue(name)
+      @stacks = subscriber_config.stacks
+    end
+
+    def produce(queue)
+      message = @sqs_queue.receive_message(attributes: [:all])
+      if message
+        queue << message
+      end
+    end
+
+    def consume(message)
+      event = Event.deserialize(message.body)
+      @stacks.each do |stack|
+        if stack.handles?(event)
+          stack.to_app.call(event: event)
+          message.delete
+        end
+      end
+    end
+
+  end
+end

data/lib/fare/subscriber_cli.rb

@@ -0,0 +1,270 @@
+require "daemonic"
+
+module Fare
+  class SubscriberCLI
+
+    attr_reader :argv, :command
+
+    def initialize(argv)
+      @command = argv.shift
+      @argv = argv
+    end
+
+    def call
+      case command
+      when nil, "-h", "--help", "help"
+        show_help
+        exit 0
+      when "start"
+        start
+      when "stop"
+        stop
+      when "status"
+        status
+      when "restart"
+        restart
+      else
+        puts "Unkown command: #{command}"
+        puts
+        show_help
+        exit 1
+      end
+    end
+
+    private
+
+    def start
+      fare_options = {
+        filename:     Fare.default_config_file,
+        environment:  (Fare.default_environment || "development"),
+      }
+      daemon_options = {
+        concurrency: 4,
+        startup_timeout: 20,
+      }
+      subscriber_options = {}
+      optparser = OptionParser.new do |parser|
+
+        parser.banner = "Usage: fare subscriber start [options]"
+
+
+        parser.on "-E", "--environment ENV", "Set the environment (default: #{fare_options[:environment]})" do |environment|
+          fare_options[:environment] = environment
+        end
+
+        parser.on "--filename FILENAME", "Location of the Fare configuration file (default: #{fare_options[:filename]})" do |filename|
+          fare_options[:filename] = filename
+        end
+
+        parser.on "--name NAME", "Which named subscriber to run (default is the unnamed one)" do |name|
+          subscriber_options[:name] = name
+        end
+
+        parser.separator ""
+        parser.separator "Process options:"
+
+        parser.on "-c", "--concurrency NUM", Integer, "Set the number of threads (default: #{daemon_options[:concurrency]}" do |concurrency|
+          daemon_options[:concurrency] = concurrency
+        end
+
+        parser.on "-P", "--pid FILE", "The location of the PID file (required when daemonizing)" do |pid|
+          daemon_options[:pid] = pid
+        end
+
+        parser.on "--[no-]daemonize", "Should the subscriber detach?" do |daemonize|
+          daemon_options[:daemonize] = daemonize
+        end
+
+        parser.on "--startup-timeout TIMEOUT", Integer, "How long to wait for the process to start (default: #{daemon_options[:startup_timeout]})" do |timeout|
+          daemon_options[:startup_timeout] = timeout
+        end
+
+        parser.separator ""
+        parser.separator "Logging options:"
+
+        parser.on "--log FILE", "Where to log to" do |log|
+          daemon_options[:log] = log
+        end
+
+        parser.on "--log-level LEVEL", %w(debug info warn fatal), "Set the log level (default: info)" do |level|
+          daemon_options[:log_level] = Logger.const_get(level.upcase)
+        end
+
+        parser.separator ""
+        parser.separator "Other options:"
+
+        parser.on_tail "-h", "--help", "Shows this help page" do
+          puts parser
+          exit
+        end
+
+      end
+
+      optparser.parse!(argv)
+
+
+      Daemonic.start(daemon_options) {
+        Fare.config(fare_options)
+        Subscriber.new(Fare.configuration, subscriber_options)
+      }
+    end
+
+    def stop
+      daemon_options = {
+        stop_timeout: 10
+      }
+      optparser = OptionParser.new do |parser|
+
+        parser.banner = "Usage: fare subscriber stop [options]"
+
+
+        parser.separator ""
+        parser.separator "Process options:"
+
+        parser.on "-P", "--pid FILE", "The location of the PID file" do |pid|
+          daemon_options[:pid] = pid
+        end
+
+        parser.on "--stop-timeout TIMEOUT", Integer, "How long to wait for the process to stop (default: #{daemon_options[:stop_timeout]})" do |timeout|
+          daemon_options[:stop_timeout] = timeout
+        end
+
+        parser.separator ""
+        parser.separator "Other options:"
+
+        parser.on_tail "-h", "--help", "Shows this help page" do
+          puts parser
+          exit
+        end
+
+      end
+
+      optparser.parse!(argv)
+
+      Daemonic.stop(daemon_options)
+    end
+
+    def restart
+      fare_options = {
+        filename:     Fare.default_config_file,
+        environment:  (Fare.default_environment || "development"),
+      }
+      daemon_options = {
+        concurrency: 4,
+        stop_timeout: 10,
+        startup_timeout: 20,
+      }
+      subscriber_options = {}
+      optparser = OptionParser.new do |parser|
+
+        parser.banner = "Usage: fare subscriber start [options]"
+
+        parser.on "-E", "--environment ENV", "Set the environment (default: #{fare_options[:environment]})" do |environment|
+          fare_options[:environment] = environment
+        end
+
+        parser.on "--filename FILENAME", "Location of the Fare configuration file (default: #{fare_options[:filename]})" do |filename|
+          fare_options[:filename] = filename
+        end
+
+        parser.on "--name NAME", "Which named subscriber to run (default is the unnamed one)" do |name|
+          subscriber_options[:name] = name
+        end
+
+        parser.separator ""
+        parser.separator "Process options:"
+
+        parser.on "-c", "--concurrency NUM", Integer, "Set the number of threads (default: #{daemon_options[:concurrency]}" do |concurrency|
+          daemon_options[:concurrency] = concurrency
+        end
+
+        parser.on "-P", "--pid FILE", "The location of the PID file (required)" do |pid|
+          daemon_options[:pid] = pid
+        end
+
+        parser.on "--startup-timeout TIMEOUT", Integer, "How long to wait for the process to start (default: #{daemon_options[:startup_timeout]})" do |timeout|
+          daemon_options[:startup_timeout] = timeout
+        end
+
+        parser.on "--stop-timeout TIMEOUT", Integer, "How long to wait for the process to stop (default: #{daemon_options[:stop_timeout]})" do |timeout|
+          daemon_options[:stop_timeout] = timeout
+        end
+
+        parser.separator ""
+        parser.separator "Logging options:"
+
+        parser.on "--log FILE", "Where to log to" do |log|
+          daemon_options[:log] = log
+        end
+
+        parser.on "--log-level LEVEL", %w(debug info warn fatal), "Set the log level (default: info)" do |level|
+          daemon_options[:log_level] = Logger.const_get(level.upcase)
+        end
+
+        parser.separator ""
+        parser.separator "Other options:"
+
+        parser.on_tail "-h", "--help", "Shows this help page" do
+          puts parser
+          exit
+        end
+
+      end
+
+      optparser.parse!(argv)
+
+      Daemonic.restart(daemon_options) {
+        Fare.config(fare_options)
+        Subscriber.new(Fare.configuration, subscriber_options)
+      }
+    end
+
+    def status
+      daemon_options = {
+      }
+      optparser = OptionParser.new do |parser|
+
+        parser.banner = "Usage: fare subscriber status [options]"
+
+        parser.separator ""
+        parser.separator "Process options:"
+
+        parser.on "-P", "--pid FILE", "The location of the PID file" do |pid|
+          daemon_options[:pid] = pid
+        end
+
+        parser.separator ""
+        parser.separator "Other options:"
+
+        parser.on_tail "-h", "--help", "Shows this help page" do
+          puts parser
+          exit
+        end
+
+      end
+
+      optparser.parse!(argv)
+
+      Daemonic.status(daemon_options)
+    end
+
+    def show_help
+      puts <<-HELP.gsub(/^ +/, '')
+        Usage: fare subscriber COMMAND [OPTIONS]
+
+        Available commands:
+
+        fare subscriber start [options]
+        fare subscriber stop [options]
+        fare subscriber status [options]
+        fare subscriber restart [options]
+
+        You can run any command with the --help option.
+
+        Example: fare subscriber start --help
+      HELP
+    end
+
+
+  end
+end