binnacle 0.4.8

data/lib/binnacle/trap/middleware.rb

@@ -0,0 +1,45 @@
+module Binnacle
+  module Trap
+    class Middleware
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        _, headers, _ = response = @app.call(env)
+        response
+      rescue Exception => exception
+        if report?(exception, headers)
+          begin
+            Binnacle.binnacle_logger.debug "Binnacle: reporting exception: #{exception.class.name}"
+            Binnacle.report_exception(exception, env)
+          rescue
+            # prevent the observer effect
+          ensure
+            raise
+          end
+        else
+          raise
+        end
+      end
+
+      def report?(exception, headers)
+        exception_class_name = exception.class.name
+        if Binnacle.configuration.trap?
+          if Binnacle.configuration.ignore_cascade_pass?
+            if headers && headers['X-Cascade']
+              report = headers['X-Cascade'] != 'pass'
+            else
+              report = true
+            end
+          end
+          Binnacle.configuration.ignored_exceptions.include?(exception_class_name) ? false : report
+        else
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/binnacle/trap/railtie.rb

@@ -0,0 +1,28 @@
+module Binnacle
+  module Trap
+    class Railtie < ::Rails::Railtie
+      initializer "binnacle.middleware" do |app|
+        Binnacle.binnacle_logger.info "Installing Rails Binnacle Middleware..."
+
+        # Exception Trapping
+        if ::Rails::VERSION::MAJOR >= 5
+          app.config.middleware.insert_after ActionDispatch::DebugExceptions, Binnacle::Trap::Middleware
+        else
+          exception_class = defined?(ActionDispatch::DebugExceptions) ? "DebugExceptions" : "ShowExceptions"
+          app.config.middleware.insert_after "ActionDispatch::#{exception_class}", "Binnacle::Trap::Middleware"
+        end
+      end
+
+      # Logging
+      config.before_configuration do |app|
+        app.config.log_tags = [ :uuid, :remote_ip ]
+      end
+
+      config.after_initialize do |app|
+        if Binnacle.configuration.intercept_rails_logging? && !Binnacle.configuration.rails_verbose_logging?
+          Binnacle::Logging::RequestLogSubscriber.attach_to :action_controller
+        end
+      end
+    end
+  end
+end

data/lib/binnacle/version.rb

@@ -0,0 +1,3 @@
+module Binnacle
+  VERSION = "0.4.8"
+end

data/lib/generators/binnacle/binnacle_generator.rb

@@ -0,0 +1,78 @@
+require 'rails/generators'
+require 'yaml'
+
+class BinnacleGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  gem "binnacle"
+
+  desc "Generates Binnacle Initialization Artifacts: initializer, firebase cloud messaging (fcm) artifacts (optional)"
+
+  class_option :firebase, type: :boolean, default: false, description: "Generated artifacts for Firebase Cloud Messaging"
+
+  def create_initializer_file
+
+    initializer "binnacle.rb" do
+      YAML::load(<<-EOM)
+      |
+      # #{'=' * 78}
+      # Binnacle Configuration
+      # #{'=' * 78}
+      # Available parameters (preferably configure via ENV):
+      # #{'=' * 78}
+      # - url:         The Binnacle Endpoint URL (BINNACLE_URL)
+      # - logging_channel: The application logger Binnacle Channel (BINNACLE_APP_LOG_CHANNEL)
+      # - error_channel:   The application error Binnacle Channel (BINNACLE_APP_ERR_CHANNEL)
+      # - api_key:     An approved publisher API key for the App (BINNACLE_API_KEY)
+      # - api_secret:  The API secret for the given API key (BINNACLE_API_SECRET)
+      # - intercept_rails_logging: Redirect rails logging to logging_channel (BINNACLE_RAILS_LOG)
+      # - report_exceptions: Trap exceptions are log them to error_channel (BINNACLE_REPORT_EXCEPTIONS)
+      # #{'=' * 78}
+      Binnacle.configure do |config|
+        config.intercept_rails_logging = false
+        config.report_exceptions = false
+      end
+      EOM
+    end
+  end
+
+  def create_web_app_manifest_for_firebase
+    if options.firebase?
+      create_file "app/assets/javascripts/manifest.json", { gcm_sender_id: "103953800507" }.to_json
+
+      app_layout = find_application_layout
+      manifest_include = ActionController::Base.helpers.tag(:link, rel: 'manifest', href: "/manifest.json")
+
+      if app_layout
+        inject_into_file app_layout, before: "</head>\n" do
+          manifest_include
+        end
+      else
+        warn " #{'warning:'.red} couldn't find application layout. add manifest declaration manually to your layout's <head> section:"
+        warn "      #{manifest_include}"
+      end
+
+      append_to_file "config/initializers/assets.rb", "Rails.application.config.assets.precompile += %w( manifest.json firebase-messaging-sw.js )\n"
+      inject_into_file "config/application.rb", %[    config.assets.paths << Rails.root.join("app", "assets", "service_workers")\n], :after => "Rails::Application\n"
+
+      template "firebase-messaging-sw.js.erb", "app/assets/service_workers/firebase-messaging-sw.js.erb"
+
+      routes = <<-ROUTES
+  get 'manifest.json', to: redirect(ActionController::Base.helpers.asset_path('manifest.json'))
+  get 'firebase-messaging-sw.js', to: -> (env) do
+    [200, { 'Content-Type' => 'application/javascript' }, [Rails.application.assets_manifest.find_sources('firebase-messaging-sw.js').first]]
+  end
+       ROUTES
+
+      inject_into_file "config/routes.rb", routes, :before => /^end/
+    end
+  end
+
+  private
+
+  def find_application_layout
+    layouts = %w[html.erb html.haml html.slim erb haml slim].map do |extension|
+      "app/views/layouts/application.#{extension}"
+    end.find { |layout| File.exist?(layout) }
+  end
+end

data/lib/generators/binnacle/templates/firebase-messaging-sw.js.erb

@@ -0,0 +1,35 @@
+// [START initialize_firebase_in_sw]
+// Give the service worker access to Firebase Messaging.
+// Note that you can only use Firebase Messaging here, other Firebase libraries
+// are not available in the service worker.
+importScripts('https://www.gstatic.com/firebasejs/3.5.2/firebase-app.js');
+importScripts('https://www.gstatic.com/firebasejs/3.5.2/firebase-messaging.js');
+
+// Initialize the Firebase app in the service worker by passing in the
+// messagingSenderId.
+firebase.initializeApp({
+  'messagingSenderId': '<%= ENV["BINNACLE_FIREBASE_SENDER_ID"] %>'
+});
+
+// Retrieve an instance of Firebase Messaging so that it can handle background
+// messages.
+const messaging = firebase.messaging();
+// [END initialize_firebase_in_sw]
+
+// If you would like to customize notifications that are received in the
+// background (Web app is closed or not in browser focus) then you should
+// implement this optional method.
+// [START background_handler]
+messaging.setBackgroundMessageHandler(function(payload) {
+  console.log('[firebase-messaging-sw.js] Received background message ', payload);
+  // Customize notification here
+  const notificationTitle = 'Background Message Title';
+  const notificationOptions = {
+    body: 'Background Message body.',
+    icon: '/firebase-logo.png'
+  };
+
+  return self.registration.showNotification(notificationTitle,
+      notificationOptions);
+});
+// [END background_handler]

data/spec/adapters/ethon_adapter.rb

@@ -0,0 +1,19 @@
+require "ethon"
+class EthonAdapter < HTTPBaseAdapter
+  def send_get_request
+    url = @data
+    easy = Ethon::Easy.new
+    easy.http_request(parse_uri.to_s, :get, { headers: @headers, params: @data })
+    easy.perform
+  end
+
+  def send_post_request
+    easy = Ethon::Easy.new
+    easy.http_request(parse_uri.to_s, :post, { headers: @headers, body: query_string })
+    easy.perform
+  end
+
+  def self.is_libcurl?
+    true
+  end
+end

data/spec/adapters/excon_adapter.rb

@@ -0,0 +1,10 @@
+require 'excon'
+class ExconAdapter < HTTPBaseAdapter
+  def send_get_request
+    Excon.get(parse_uri.to_s, headers: @headers )
+  end
+
+  def send_post_request
+    Excon.post(parse_uri.to_s, body: query_string, headers: @headers)
+  end
+end

data/spec/adapters/faraday_adapter.rb

@@ -0,0 +1,46 @@
+require 'faraday'
+class FaradayAdapter < HTTPBaseAdapter
+  def send_get_request
+    connection.get do |req|
+      req.url parse_uri.to_s
+      req.headers = @headers
+    end
+  end
+
+  def send_post_request
+    connection.post do |req|
+      req.url parse_uri.to_s
+      req.headers = @headers
+      req.body = query_string
+    end
+  end
+
+  def send_post_form_request
+    connection.post do |req|
+      req.url parse_uri.to_s
+      req.headers = @headers
+      req.body = @params
+    end
+  end
+
+  def send_multipart_post_request
+    file_upload = Faraday::UploadIO.new(@params['file'], 'text/plain')
+
+    connection.post do |req|
+      req.url parse_uri.to_s
+      req.headers = @headers
+      req.body = @params.merge('file' => file_upload)
+    end
+  end
+
+  private
+
+  def connection
+    Faraday.new(url: "#{@protocol}://#{@host}:#{@port}") do |faraday|
+      faraday.request :multipart
+      faraday.request :url_encoded
+
+      faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+    end
+  end
+end

data/spec/adapters/http_adapter.rb

@@ -0,0 +1,14 @@
+require 'http'
+class HTTPAdapter < HTTPBaseAdapter
+  def send_get_request
+    HTTP.headers(@headers).get(parse_uri.to_s)
+  end
+
+  def send_post_request
+    HTTP.headers(@headers).post(parse_uri.to_s, body: query_string)
+  end
+
+  def send_post_form_request
+    HTTP.headers(@headers).post(parse_uri.to_s, form: @params)
+  end
+end

data/spec/adapters/http_base_adapter.rb

@@ -0,0 +1,37 @@
+require 'uri'
+
+class HTTPBaseAdapter
+  def initialize(host, port, path, headers, data, params, protocol = 'http')
+    @host = host
+    @port = port
+    @path = path
+    @headers = headers
+    @data = data
+    @params = params
+    @protocol = protocol
+  end
+
+  def logs_data?
+    true
+  end
+
+  def parse_uri
+    URI.parse("#{@protocol}://#{@host}:#{@port}#{@path}")
+  end
+
+  def expected_response_body
+    "\n<html>"
+  end
+
+  def self.is_libcurl?
+    false
+  end
+
+  def self.should_log_headers?
+    true
+  end
+
+  def query_string
+    URI.encode_www_form(@data)
+  end
+end

data/spec/adapters/httparty_adapter.rb

@@ -0,0 +1,10 @@
+require 'httparty'
+class HTTPartyAdapter < HTTPBaseAdapter
+  def send_get_request
+    HTTParty.get(parse_uri.to_s, headers: @headers)
+  end
+
+  def send_post_request
+    HTTParty.post(parse_uri.to_s, body: query_string, headers: @headers)
+  end
+end

data/spec/adapters/httpclient_adapter.rb

@@ -0,0 +1,21 @@
+class HTTPClientAdapter < HTTPBaseAdapter
+  def send_get_request
+    ::HTTPClient.get(parse_uri, header: @headers)
+  end
+
+  def send_post_request
+    ::HTTPClient.post(parse_uri, body: query_string, header: @headers)
+  end
+
+  def send_post_form_request
+    ::HTTPClient.post(parse_uri, body: @params, header: @headers)
+  end
+
+  def send_multipart_post_request
+    send_post_form_request
+  end
+
+  def self.response_should_be
+    HTTP::Message
+  end
+end

data/spec/adapters/net_http_adapter.rb

@@ -0,0 +1,14 @@
+class NetHTTPAdapter < HTTPBaseAdapter
+  def send_get_request
+    Net::HTTP.get_response(@host, [@path, query_string].compact.join('?'), @port)
+  end
+
+  def send_post_request
+    http = Net::HTTP.new(@host, @port)
+    resp = http.post(@path, query_string)
+  end
+
+  def send_post_form_request
+    res = Net::HTTP.post_form(parse_uri, @params)
+  end
+end

data/spec/adapters/open_uri_adapter.rb

@@ -0,0 +1,17 @@
+class OpenUriAdapter < HTTPBaseAdapter
+  def send_get_request
+    open(parse_uri)
+  end
+
+  def expected_response_body
+    " (not available yet)"
+  end
+
+  def self.should_log_headers?
+    false
+  end
+
+  def logs_data?
+    false
+  end
+end

data/spec/adapters/patron_adapter.rb

@@ -0,0 +1,29 @@
+require "patron"
+class PatronAdapter < HTTPBaseAdapter
+  def send_get_request
+    session = Patron::Session.new
+    session.get(parse_uri.to_s, @headers)
+  end
+
+  def send_post_request
+    session = Patron::Session.new
+    session.post(parse_uri.to_s, query_string, @headers)
+  end
+
+  def send_post_form_request
+    session = Patron::Session.new
+    session.post(parse_uri.to_s, @params, @headers)
+  end
+
+  def send_multipart_post_request
+    data = @params.dup
+    file = @params.delete('file')
+
+    session = Patron::Session.new
+    session.post_multipart(parse_uri.to_s, data, {file: file.path}, @headers)
+  end
+
+  def self.is_libcurl?
+    true
+  end
+end

data/spec/adapters/typhoeus_adapter.rb

@@ -0,0 +1,25 @@
+class TyphoeusAdapter < HTTPBaseAdapter
+
+  def send_get_request
+    #response = Typhoeus.get(parse_uri.to_s, headers: @headers, params: @data)
+    hydra = Typhoeus::Hydra.new
+    hydra.queue(Typhoeus::Request.new(parse_uri.to_s, headers: @headers, params: @data))
+    hydra.run
+  end
+
+  def send_post_request
+    Typhoeus.post(parse_uri.to_s, body: query_string, headers: @headers)
+  end
+
+  def send_post_form_request
+    Typhoeus.post(parse_uri.to_s, body: @params, headers: @headers)
+  end
+
+  def send_multipart_post_request
+    send_post_form_request
+  end
+
+  def self.is_libcurl?
+    true
+  end
+end