roo_on_rails 1.20.0 → 2.1.0

data/.travis.yml

@@ -1,34 +0,0 @@
-sudo: required
-language: ruby
-rvm:
-  - 2.2.7
-  - 2.3.3
-  - 2.4.1
-  - ruby-head
-gemfile:
-  - gemfiles/rails_3.gemfile
-  - gemfiles/rails_4.gemfile
-  - gemfiles/rails_5.gemfile
-  - gemfiles/rails_5_1.gemfile
-install:
-  - bundle install --jobs=3 --retry=3 --path=vendor/bundle
-cache:
-  bundler: true
-  directories:
-    - vendor/bundle
-    - vendor/bundle-scaffold
-before_script:
-  - unset RACK_ENV
-  - unset RAILS_ENV
-  - mkdir -p $PWD/tmp && sudo mount -t tmpfs -o size=1024m tmpfs $PWD/tmp
-  - gem install bundler
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-  exclude:
-    - rvm: 2.4.1
-      gemfile: gemfiles/rails_3.gemfile
-    - rvm: ruby-head
-      gemfile: gemfiles/rails_3.gemfile
-services:
-  - redis-server

data/README.routemaster_client.md

@@ -1,103 +0,0 @@
-## Using the Routemaster Client feature
-
-[`routemaster-client`](https://github.com/deliveroo/routemaster-client) comes as a dependency of `roo_on_rails` with a basic implementation of lifecycle event publishers.
-
-This code example assumes that you are using the latest version of the [`roo_on_rails`](https://github.com/deliveroo/roo_on_rails) gem and that you have set the correct environment variables for Routemaster Client to work on your app, as explained in the main [`README.md`](https://github.com/deliveroo/roo_on_rails#routemaster-client) file.
-
-It also assumes that your app has an API for the resources you want to publish lifecycle events for, with matching routes and an `API_HOST` environment variable set.
-
-### Setup lifecycle events for your models
-
-You can use publish events on create, update, and destroy by including the `PublishLifecycleEvents` module:
-
-```ruby
-# app/models/order.rb
-require 'roo_on_rails/routemaster/publish_lifecycle_events'
-
-class Order < ApplicationRecord
-  include RooOnRails::Routemaster::PublishLifecycleEvents
-
-  # ...
-end
-```
-
-If you need more control over which events are published you can use the base module `LifecycleEvents` and specify them explicitly:
-
-```ruby
-# app/models/rider.rb
-require 'roo_on_rails/routemaster/lifecycle_events'
-
-class Rider < ApplicationRecord
-  include RooOnRails::Routemaster::LifecycleEvents
-
-  publish_lifecycle_events :create, :destroy
-
-  # ...
-end
-```
-
-### Create publishers for lifecycle events
-
-We have now configured our models to publish lifecycle events to Routemaster, but it won't send anything until you have enabled publishing and created matching publishers. Let's start with creating an `ApplicationPublisher` that we can use as our default.
-
-```ruby
-# app/publishers/application_publisher.rb
-require 'roo_on_rails/routemaster/publisher'
-
-class ApplicationPublisher < RooOnRails::Routemaster::Publisher
-  include Rails.application.routes.url_helpers
-
-  def url
-    url_helper = :"api_#{model.class.name.underscore}_url"
-    public_send(url_helper, model.id, host: ENV.fetch('API_HOST'), protocol: 'https')
-  end
-
-  # Add your method overrides here if needed
-end
-```
-
-If different behaviour is needed for specific models then you can override the defaults in their publishers:
-
-```ruby
-# app/publishers/order_publisher.rb
-class OrderPublisher < ApplicationPublisher
-  def async?
-    true
-  end
-end
-```
-
-and
-
-```ruby
-# app/publishers/rider_publisher.rb
-class RiderPublisher < ApplicationPublisher
-  def topic
-    'a_different_rider_topic'
-  end
-end
-```
-
-`#publish?`, `#topics`, `#async?`, `#data` and `#timestamp` can be overriden; see [the `Publisher` class](lib/roo_on_rails/routemaster/publisher.rb) for the default implementations.
-
-### Register the publishers with Routemaster
-
-The final step is to tell Routemaster that these publishers exist, so that it can listen to their events. We're going to do this in an initialiser:
-
-```ruby
-# config/initilizers/routemaster.rb
-require 'roo_on_rails/routemaster/publishers'
-
-PUBLISHERS = [
-  OrderPublisher,
-  RiderPublisher
-].freeze
-
-RooOnRails::Routemaster::Publishers.register_default(ApplicationPublisher)
-PUBLISHERS.each do |publisher|
-  model_class = publisher.to_s.gsub("Publisher", "").constantize
-  RooOnRails::Routemaster::Publishers.register(publisher, model_class: model_class)
-end
-```
-
-We should now be all set for our app to publish lifecycle events for all our models onto the event bus, with special behaviour for `orders` and `riders`, so that other apps can listen to them.

data/lib/roo_on_rails/railties/logging.rb

@@ -1,25 +0,0 @@
-module RooOnRails
-  module Railties
-    class Logging < Rails::Railtie
-      initializer 'roo_on_rails.logging.before', before: :initialize_logger do
-        require 'roo_on_rails/logger'
-        Rails.logger = config.logger = RooOnRails::Logger.new
-        # It is not possible to set log_level to an invalid value without some
-        # deliberate gymnastics (the setter will raise an error), and Rails
-        # defaults this to `debug`, so we don't need to guard against nil /
-        # invalidity
-        log_level = Rails.configuration.log_level
-
-        Rails.logger.set_log_level(default: log_level)
-        Rails.logger.debug 'initializer roo_on_rails.logging.before'
-      end
-
-      initializer 'roo_on_rails.logging.after', after: :initialize_logger do
-        log_level = Rails.configuration.log_level
-
-        Rails.logger.set_log_level(default: log_level)
-        Rails.logger.debug 'initializer roo_on_rails.logging.after'
-      end
-    end
-  end
-end

data/lib/roo_on_rails/railties/new_relic.rb

@@ -1,32 +0,0 @@
-module RooOnRails
-  module Railties
-    class NewRelic < Rails::Railtie
-      initializer 'roo_on_rails.new_relic' do
-        Rails.logger.with initializer: 'roo_on_rails.new_relic' do |log|
-          log.debug 'loading'
-          license_key = ENV['NEW_RELIC_LICENSE_KEY']
-
-          if %w(test development).exclude?(Rails.env.to_s) && (license_key == 'override-me')
-            abort 'Aborting: NEW_RELIC_LICENSE_KEY must be set in production environments'
-          end
-
-          abort 'Aborting: NEW_RELIC_LICENSE_KEY is required' if license_key.nil?
-
-          path = %w(newrelic.yml config/newrelic.yml).map do |p|
-            Pathname.new(p)
-          end.find(&:exist?)
-          if path
-            abort "Aborting: newrelic.yml detected in '#{path.parent.realpath}', should not exist"
-          end
-
-          sync_startup = (ENV.fetch('NEW_RELIC_SYNC_STARTUP', 'YES') =~ /\A(YES|TRUE|ON|1)\Z/i)
-
-          require 'newrelic_rpm'
-          unless Rails.env.test?
-            ::NewRelic::Control.instance.init_plugin(sync_startup: sync_startup)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/roo_on_rails/railties/routemaster.rb

@@ -1,42 +0,0 @@
-require 'roo_on_rails/config'
-
-module RooOnRails
-  module Railties
-    class Routemaster < Rails::Railtie
-      initializer 'roo_on_rails.routemaster' do
-        Rails.logger.with initializer: 'roo_on_rails.routemaster' do |log|
-          next unless Config.routemaster_enabled?
-          log.debug 'loading'
-
-          abort 'Aborting: ROUTEMASTER_URL and ROUTEMASTER_UUID are required' if bus_details_missing?
-
-          require 'routemaster/client'
-
-          ::Routemaster::Client.configure do |config|
-            config.url = routemaster_url
-            config.uuid = routemaster_uuid
-            config.verify_ssl = routemaster_verify_ssl
-          end
-        end
-      end
-
-      private
-
-      def bus_details_missing?
-        routemaster_url.blank? || routemaster_uuid.blank?
-      end
-
-      def routemaster_url
-        ENV.fetch('ROUTEMASTER_URL')
-      end
-
-      def routemaster_uuid
-        ENV.fetch('ROUTEMASTER_UUID')
-      end
-
-      def routemaster_verify_ssl
-        ENV.fetch('ROUTEMASTER_VERIFY_SSL', 'true') != 'false'
-      end
-    end
-  end
-end

data/lib/roo_on_rails/routemaster/lifecycle_events.rb

@@ -1,64 +0,0 @@
-require 'active_support/concern'
-require 'new_relic/agent'
-require 'roo_on_rails/routemaster/publishers'
-
-module RooOnRails
-  module Routemaster
-    module LifecycleEvents
-      extend ActiveSupport::Concern
-
-      ACTIVE_RECORD_TO_ROUTEMASTER_EVENT_MAP = {
-        create: :created,
-        update: :updated,
-        destroy: :deleted,
-        noop: :noop
-      }.freeze
-      private_constant :ACTIVE_RECORD_TO_ROUTEMASTER_EVENT_MAP
-
-      def publish_lifecycle_event(event)
-        publish_event(event, force_publish: false)
-      end
-
-      def publish_lifecycle_event!(event)
-        publish_event(event, force_publish: true)
-      end
-
-      private
-
-      def publish_event(event, force_publish:)
-        publishers = Routemaster::Publishers.for(self, routemaster_event_type(event))
-        publishers.each do |publisher|
-          begin
-            publisher.publish!(force_publish: force_publish)
-          rescue => e
-            NewRelic::Agent.notice_error(e)
-          end
-        end
-      end
-
-      def routemaster_event_type(event)
-        ACTIVE_RECORD_TO_ROUTEMASTER_EVENT_MAP[event].tap do |type|
-          raise "invalid lifecycle event '#{event}'" unless type
-        end
-      end
-
-      %i(create update destroy noop).each do |event|
-        define_method("publish_lifecycle_event_on_#{event}") do
-          publish_lifecycle_event(event)
-        end
-      end
-
-      module ClassMethods
-        def publish_lifecycle_events(*events)
-          events = events.any? ? events : %i(create update destroy)
-          events.each do |event|
-            after_commit(
-              :"publish_lifecycle_event_on_#{event}",
-              on: event
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/roo_on_rails/routemaster/publish_lifecycle_events.rb

@@ -1,13 +0,0 @@
-require 'active_support/concern'
-require 'roo_on_rails/routemaster/lifecycle_events'
-
-module RooOnRails
-  module Routemaster
-    module PublishLifecycleEvents
-      extend ActiveSupport::Concern
-      include LifecycleEvents
-
-      included(&:publish_lifecycle_events)
-    end
-  end
-end

data/lib/roo_on_rails/routemaster/publisher.rb

@@ -1,74 +0,0 @@
-require 'roo_on_rails/config'
-require 'routemaster/client'
-
-module RooOnRails
-  module Routemaster
-    class Publisher
-      attr_reader :model, :event
-
-      def initialize(model, event, client: ::Routemaster::Client)
-        @model = model
-        @event = event
-        @client = client
-      end
-
-      def publish?
-        noop? || @model.new_record? || @model.previous_changes.any?
-      end
-
-      def will_publish?(force_publish: false)
-        Config.routemaster_publishing_enabled? && (force_publish || publish?)
-      end
-
-      def publish!(force_publish: false)
-        return unless will_publish?(force_publish: force_publish)
-        @client.send(
-          @event,
-          topic,
-          url,
-          async: async?,
-          data: stringify_keys(data),
-          t: timestamp && (timestamp.to_f * 1000).to_i
-        )
-      end
-
-      def topic
-        @model.class.name.tableize
-      end
-
-      def url
-        raise NotImplementedError
-      end
-
-      def async?
-        false
-      end
-
-      def data
-        nil
-      end
-
-      def timestamp
-        return @model.created_at if created? && @model.respond_to?(:created_at)
-        return @model.updated_at if (updated? || created?) && @model.respond_to?(:updated_at)
-        nil
-      end
-
-      %i(created updated deleted noop).each do |event_type|
-        define_method :"#{event_type}?" do
-          @event.to_sym == event_type
-        end
-      end
-
-      private
-
-      def stringify_keys(hash)
-        return hash if hash.nil? || hash.empty?
-
-        hash.each_with_object({}) do |(k, v), h|
-          h[k.to_s] = v.is_a?(Hash) ? stringify_keys(v) : v
-        end
-      end
-    end
-  end
-end

data/lib/roo_on_rails/routemaster/publishers.rb

@@ -1,27 +0,0 @@
-module RooOnRails
-  module Routemaster
-    module Publishers
-      @default_publishers = []
-      @publishers = {}
-
-      def self.register_default(publisher_class)
-        @default_publishers << publisher_class
-      end
-
-      def self.register(publisher_class, model_class:)
-        @publishers[model_class.name] ||= Set.new
-        @publishers[model_class.name] << publisher_class
-      end
-
-      def self.for(model, event)
-        publisher_classes = @publishers[model.class.name] || @default_publishers
-        publisher_classes.map { |c| c.new(model, event) }
-      end
-
-      def self.clear
-        @default_publishers = []
-        @publishers = {}
-      end
-    end
-  end
-end

data/lib/roo_on_rails/tasks/newrelic.rake

@@ -1,25 +0,0 @@
-namespace :newrelic do
-  desc 'Notifies New Relic that a deployment has occurred'
-  task notice_deployment: :environment do
-    begin
-      require 'newrelic_rpm'
-      require 'new_relic/cli/command'
-
-      appname = ENV.fetch('NEW_RELIC_APP_NAME')
-
-      Rails.logger.info("Notifying New Relic of deployment to #{appname}")
-      NewRelic::Cli::Deployments.new(
-        environment: Rails.env.to_s,
-        revision: ENV.fetch('SOURCE_VERSION', 'unknown'),
-        changelog: '',
-        description: '',
-        appname: appname,
-        user: '',
-        license_key: ENV.fetch('NEW_RELIC_LICENSE_KEY')
-      ).run
-    rescue => e
-      Rails.logger.error("Failed to notify New Relic (#{e.class.name}: #{e.message})")
-      Rails.logger.info(e.backtrace.take(10).join("\n"))
-    end
-  end
-end