service_template 0.5.0

data/lib/service_template/grape_extensions/grape_helpers.rb

@@ -0,0 +1,27 @@
+module ServiceTemplate
+  module GrapeHelpers
+    def represent(data, with: nil, **args)
+      raise ArgumentError.new(":with option is required") if with.nil?
+
+      if data.respond_to?(:to_a)
+        return { data: data.map{ |item| with.new(item).to_hash(args) } }
+      else
+        return { data: with.new(data).to_hash(args)}
+      end
+    end
+
+    def present_error(code, message = '', reasons={})
+      ServiceTemplate::JsonError.new(code, message, reasons)
+    end
+
+    def permitted_params(options = {})
+      options = { include_missing: false }.merge(options)
+      declared(params, options)
+    end
+
+    # extend all endpoints to include this
+    Grape::Endpoint.send :include, self if defined?(Grape)
+    # rails 4 controller concern
+    extend ActiveSupport::Concern if defined?(Rails)
+  end
+end

data/lib/service_template/identity.rb

@@ -0,0 +1,45 @@
+module ServiceTemplate
+  class Identity
+    def self.health
+      {
+        name: name,
+        hostname: hostname,
+        revision: revision,
+        pid: pid,
+        parent_pid: parent_pid,
+        platform: platform
+      }
+    end
+
+    def self.name
+      ENV['SERVICE_NAME'] || 'api-service'
+    end
+
+    def self.hostname
+      @hostname ||= `hostname`.strip
+    end
+
+    def self.revision
+      @revision ||= `git rev-parse HEAD`.strip
+    end
+
+    def self.pid
+      @pid ||= Process.pid
+    end
+
+    def self.parent_pid
+      @ppid ||= Process.ppid
+    end
+
+    def self.platform
+      {
+        version: platform_revision,
+        name: "ServiceTemplate"
+      }
+    end
+
+    def self.platform_revision
+      ServiceTemplate::VERSION
+    end
+  end
+end

data/lib/service_template/json_error.rb

@@ -0,0 +1,24 @@
+module ServiceTemplate
+  class JsonError
+    def initialize(code, message, reasons={})
+      @code = code
+      @message = message
+      @reasons = reasons
+    end
+
+    def to_json(options = {})
+      to_h.to_json(options)
+    end
+
+    def to_h
+      e = {
+        error: {
+          code: @code,
+          message: @message
+        }
+      }
+      e[:error][:reasons] = @reasons if @reasons.present?
+      e
+    end
+  end
+end

data/lib/service_template/logger/log_transaction.rb

@@ -0,0 +1,17 @@
+module ServiceTemplate
+  class LogTransaction
+    class << self
+      def id
+        Thread.current[:service_template_tid].nil? ? Thread.current[:service_template_tid] = SecureRandom.hex(10) : Thread.current[:service_template_tid]
+      end
+
+      def id=(id)
+        Thread.current[:service_template_tid] = id
+      end
+
+      def clear
+        Thread.current[:service_template_tid] = nil
+      end
+    end
+  end
+end

data/lib/service_template/logger/logger.rb

@@ -0,0 +1,42 @@
+module ServiceTemplate
+  class Logger
+    class << self
+      def name
+        [ServiceTemplate::Identity.name, ServiceTemplate::LogTransaction.id].join('-')
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def logger
+        unless @logger
+          Logging.appenders.stdout(
+            'stdout',
+            layout: Logging.layouts.json
+          )
+          Logging.appenders.file(
+            "log/#{ServiceTemplate.env}.log",
+            layout: Logging.layouts.json
+          )
+
+          @logger = Logging.logger["[#{name}]"]
+          @logger.add_appenders 'stdout' unless ServiceTemplate.env.test?
+          @logger.add_appenders "log/#{ServiceTemplate.env}.log"
+        end
+
+        @logger
+      end
+
+      def response(status, headers, body)
+        { response:
+          {
+            status:   status,
+            headers:  headers,
+            response: body
+          }
+        }
+      end
+    end
+  end
+end

data/lib/service_template/logger/parseable.rb

@@ -0,0 +1,37 @@
+# override what is in logging gem to ALWAYS use a structured object, rather than a string
+# original version of this: https://github.com/TwP/logging/blob/master/lib/logging/layouts/parseable.rb
+module Logging
+  module Layouts
+    class Parseable < ::Logging::Layout
+
+      # Public: Take a given object and convert it into a format suitable for
+      # inclusion as a log message. The conversion allows the object to be more
+      # easily expressed in YAML or JSON form.
+      #
+      # If the object is an Exception, then this method will return a Hash
+      # containing the exception class name, message, and backtrace (if any).
+      #
+      # If the object is a string, wrap it in a hash.
+      #
+      # obj - The Object to format
+      #
+      # Returns the formatted Object.
+      #
+      def format_obj(obj)
+        case obj
+        when Exception
+          h = { class: obj.class.name,
+                message: obj.message }
+          h[:backtrace] = obj.backtrace if @backtrace && !obj.backtrace.nil?
+          h
+        when Time
+          iso8601_format(obj)
+        when String
+          { text: obj }
+        else
+          obj
+        end
+      end
+    end  # Parseable
+  end  # Layouts
+end

data/lib/service_template/middleware/app_monitor.rb

@@ -0,0 +1,17 @@
+module ServiceTemplate
+  class Middleware
+    class AppMonitor
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if ["/health", "/health.json"].include? env['PATH_INFO']
+          [200, { 'Content-type' => 'application/json' }, [ServiceTemplate::Identity.health.to_json]]
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/service_template/middleware/authentication.rb

@@ -0,0 +1,32 @@
+module ServiceTemplate
+  class Middleware
+    class Authentication
+      def initialize(app)
+        @app = app
+
+        if ENV['HEADER_PASSWORDS']
+          @allowed_passwords = ENV['HEADER_PASSWORDS'].split(',').map { |pw| pw.strip }.freeze
+        end
+      end
+
+      def call(env)
+        if authenticated_request?(env)
+          @app.call(env)
+        else
+          if @allowed_passwords
+            error_response = ServiceTemplate::JsonError.new('bad_password', 'bad password').to_json
+          else
+            error_response = ServiceTemplate::JsonError.new('not_configured', 'password not configured').to_json
+          end
+
+          [401, { 'Content-type' => 'application/json' }, Array.wrap(error_response)]
+        end
+
+      end
+
+      def authenticated_request?(env)
+        @allowed_passwords.include? env['HTTP_PASSWORD'] unless @allowed_passwords.nil?
+      end
+    end
+  end
+end

data/lib/service_template/middleware/database_stats.rb

@@ -0,0 +1,15 @@
+module ServiceTemplate
+  class Middleware
+    class DatabaseStats
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        require 'service_template/active_record_extensions/notifications_subscriber'
+        status, headers, body = @app.call(env)
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/service_template/middleware/logger.rb

@@ -0,0 +1,67 @@
+require 'service_template/param_sanitizer'
+
+module ServiceTemplate
+  class Middleware
+    class Logger
+      include ServiceTemplate::ParamSanitizer
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        # log the request
+        ServiceTemplate::Logger.logger.info format_request(env)
+
+        # process the request
+        status, headers, body = @app.call(env)
+
+        # log the response
+        ServiceTemplate::Logger.logger.debug format_response(status, headers, body)
+
+        # return the results
+        [status, headers, body]
+      ensure
+        # Clear the transaction id after each request
+        ServiceTemplate::LogTransaction.clear
+      end
+
+      private
+
+        def format_request(env)
+          request = Rack::Request.new(env)
+          params  = request.params
+
+          begin
+            params = JSON.parse(request.body.read) if env['CONTENT_TYPE'] == 'application/json'
+          rescue
+            # do nothing, params is already set
+          end
+
+          request_data = {
+            method:           request.request_method,
+            path:             request.path_info,
+            query:            filtered_query_string(request.query_string),
+            host:             ServiceTemplate::Identity.hostname,
+            pid:              ServiceTemplate::Identity.pid,
+            revision:         ServiceTemplate::Identity.revision,
+            params:           filtered_parameters(params),
+            remote_ip:        request.ip
+          }
+          request_data[:user_id] = current_user.try(:id) if defined?(current_user)
+          { request: request_data }
+        end
+
+        def format_response(status, headers, body)
+          response_body = nil
+          begin
+            response_body = body.respond_to?(:body) ? body.body.map { |r| r } : nil
+          rescue
+            response_body = body.inspect
+          end
+
+          ServiceTemplate::Logger.response(status, headers, response_body)
+        end
+    end
+  end
+end

data/lib/service_template/middleware/request_stats.rb

@@ -0,0 +1,42 @@
+module ServiceTemplate
+  class Middleware
+    class RequestStats
+      def initialize(app)
+        @app = app
+      end
+
+      def normalize_path(path)
+        case
+          when path == '/'
+            'root'
+          else
+            path.start_with?('/') ? path[1..-1] : path
+        end
+      end
+
+      def call(env)
+        # Mark the request time
+        start = Time.now
+
+        # Process the request
+        status, headers, body = @app.call(env)
+
+        # Mark the response time
+        stop = Time.now
+
+        # Calculate total response time
+        response_time = (stop - start) * 1000
+
+        request = Rack::Request.new(env)
+        path = normalize_path(request.path_info)
+
+        # Emit stats to StatsD
+        ServiceTemplate::Stats.emitter.timing('response_time', response_time)
+        ServiceTemplate::Stats.emitter.timing("path.#{ServiceTemplate::Stats.path_to_key(request.request_method, path)}.response_time", response_time)
+
+        # Return the results
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/service_template/output_formatters/entity.rb

@@ -0,0 +1,15 @@
+module ServiceTemplate
+  class Entity < Grape::Entity
+    def self.inherited(subclass)
+      ActiveSupport::Deprecation.warn 'Use of ServiceTemplate::Entity is discouraged, please transition your code to Roar representers - https://github.com/bellycard/service_template/blob/master/docs/grape_entity_to_roar.md', caller
+    end
+
+    format_with :to_s do |val|
+      val.to_s
+    end
+
+    def object_type
+      object.class.name.underscore
+    end
+  end
+end

data/lib/service_template/output_formatters/include_nil.rb

@@ -0,0 +1,16 @@
+# include this in your representer, and you will always return all defined keys (even if their value is nil)
+module ServiceTemplate
+  module Representable
+    module IncludeNil
+      def self.included base
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def property(name, options={}, &block)
+          super(name, options.merge(render_nil: true), &block)
+        end
+      end
+    end
+  end
+end

data/lib/service_template/output_formatters/json_api_representer.rb

@@ -0,0 +1,9 @@
+require 'roar/decorator'
+require 'roar/json/json_api'
+
+module ServiceTemplate
+  class JsonApiRepresenter < Roar::Decorator
+	include Roar::JSON::JSONAPI
+
+  end
+end

data/lib/service_template/param_sanitizer.rb

@@ -0,0 +1,30 @@
+require 'action_dispatch/http/filter_parameters'
+
+module ServiceTemplate
+  module ParamSanitizer
+    include ActionDispatch::Http::FilterParameters
+
+    mattr_accessor :filter_params
+
+    KV_REGEXP   = '[^&;=]+'
+    PAIR_REGEXP = %r{(#{KV_REGEXP})=(#{KV_REGEXP})}
+
+    def filter_params
+      @@filter_params || []
+    end
+
+    def parameter_filter
+      parameter_filter_for(filter_params)
+    end
+
+    def filtered_parameters(params)
+      parameter_filter.filter(params)
+    end
+
+    def filtered_query_string(query_string)
+      query_string.gsub(PAIR_REGEXP) do |_|
+        parameter_filter.filter([[$1, $2]]).first.join("=")
+      end
+    end
+  end
+end