jersey 0.0.3

data/lib/jersey/helpers/log.rb

@@ -0,0 +1,7 @@
+module Jersey::Helpers
+  module Log
+    def log(*args)
+      env['logger'].log(*args)
+    end
+  end
+end

data/lib/jersey/http_errors.rb

@@ -0,0 +1,62 @@
+module Jersey
+  module HTTP
+    module Errors
+      HTTPError = Class.new(StandardError)
+      ClientError = Class.new(HTTPError)
+      ServerError = Class.new(HTTPError)
+
+      # Define ALL the HTTP errors as constants
+      FOUR_HUNDRED = [
+        [400, 'BadRequest', :bad_request],
+        [401, 'Unauthorized', :unauthorized],
+        [402, 'PaymentRequired', :payment_required],
+        [403, 'Forbidden', :forbidden],
+        [404, 'NotFound', :not_found],
+        [405, 'MethodNotAllowed', :method_not_allowed],
+        [406, 'NotAcceptable', :not_acceptable],
+        [407, 'ProxyAuthenticationRequired', :proxy_authentication_required],
+        [408, 'RequestTimeout', :request_timeout],
+        [409, 'Conflict', :conflict],
+        [410, 'Gone', :gone],
+        [411, 'LengthRequired', :length_required],
+        [412, 'PreconditionFailed', :precondition_failed],
+        [413, 'RequestEntityTooLarge', :request_entity_too_large],
+        [414, 'RequestURITooLong', :request_uri_too_long],
+        [415, 'UnsupportedMediaType', :unsupported_media_type],
+        [416, 'RequestedRangeNotSatisfiable', :requested_range_not_satisfiable],
+        [417, 'ExpectationFailed', :expectation_failed],
+        [422, 'UnprocessableEntity', :unprocessable_entity],
+        [423, 'Locked', :locked],
+        [424, 'FailedDependency', :failed_dependency],
+        [426, 'UpgradeRequired', :upgrade_required],
+      ]
+
+      FIVE_HUNDRED = [
+        [500, 'InternalServerError', :internal_server_error],
+        [501, 'NotImplemented', :not_implemented],
+        [502, 'BadGateway', :bad_gateway],
+        [503, 'ServiceUnavailable', :service_unavailable],
+        [504, 'GatewayTimeout', :gateway_timeout],
+        [505, 'HTTPVersionNotSupported', :http_version_not_supported],
+        [507, 'InsufficientStorage', :insufficient_storage],
+        [510, 'NotExtended', :not_extended],
+      ]
+
+      (FOUR_HUNDRED + FIVE_HUNDRED).each do |s|
+        code, const_name, symbol = s[0],s[1],s[2]
+        if code >= 500
+          klass = Class.new(ServerError)
+        else
+          klass = Class.new(ClientError)
+        end
+        klass.const_set(:STATUS_CODE, code)
+        const_set(const_name,klass)
+      end
+
+      # Take over Sinatra's NotFound so we don't have to deal with the
+      # not_found block and can raise our own NotFound error
+      ::Sinatra.send(:remove_const, :NotFound)
+      ::Sinatra.const_set(:NotFound, ::Jersey::HTTP::Errors::NotFound)
+    end
+  end
+end

data/lib/jersey/log.rb

@@ -0,0 +1,25 @@
+require 'jersey/logging/base_logger'
+require 'jersey/logging/logfmt_logger'
+require 'jersey/logging/json_logger'
+require 'jersey/logging/mixins'
+
+module Jersey
+  class Logger < LogfmtLogger
+    include Logging::LogTime
+    include Logging::LogError
+  end
+
+  module LoggingSingleton
+    attr_writer :logger
+
+    def logger
+      @logger ||= Jersey::Logger.new
+    end
+
+    def log(loggable = {})
+      logger.log(loggable)
+    end
+  end
+
+  extend LoggingSingleton
+end

data/lib/jersey/logging/base_logger.rb

@@ -0,0 +1,58 @@
+module Jersey
+  class BaseLogger
+    attr_accessor :stream, :defaults
+
+    def initialize(opts = {})
+      @stream   = opts.fetch(:stream, $stdout)
+      @defaults = opts.fetch(:defaults, {})
+    end
+
+    def <<(data)
+      @defaults.merge!(data)
+    end
+
+    def reset!(key = nil)
+      if key
+        @defaults.delete(key)
+        @defaults.delete(key.to_sym)
+      else
+        @defaults.clear
+      end
+    end
+
+    def log(data, &block)
+      log_to_stream(stream, @defaults.merge(data), &block)
+    end
+
+    private
+    def log_to_stream(stream, data, &block)
+      data.merge!(request_data || {})
+      unless block
+        str = unparse(data.merge(now: Time.now))
+        stream.print(str + "\n")
+      else
+        data = data.dup
+        start = Time.now
+        log_to_stream(stream, data.merge(at: "start"))
+        begin
+          res = yield
+          log_to_stream(stream, data.merge(
+            at: "finish", elapsed: (Time.now - start).to_f))
+          res
+        rescue
+          log_to_stream(stream, data.merge(
+            at: "exception", elapsed: (Time.now - start).to_f))
+          raise
+        end
+      end
+    end
+
+    def unparse
+      raise "Need to subclass and implement #unparse"
+    end
+
+    def request_data
+      RequestStore[:log] if defined? RequestStore
+    end
+  end
+end

data/lib/jersey/logging/json_logger.rb

@@ -0,0 +1,8 @@
+module Jersey
+  class JSONLogger < BaseLogger
+    private
+    def unparse(attrs)
+      attrs.to_json
+    end
+  end
+end

data/lib/jersey/logging/logfmt_logger.rb

@@ -0,0 +1,37 @@
+module Jersey
+  class LogfmtLogger < BaseLogger
+    private
+    def unparse(attrs)
+      attrs.map { |k, v| unparse_pair(k, v) }.compact.join(" ")
+    end
+
+    def quote_string(k, v)
+      # try to find a quote style that fits
+      if !v.include?('"')
+        %{#{k}="#{v}"}
+      elsif !v.include?("'")
+        %{#{k}='#{v}'}
+      else
+        %{#{k}="#{v.gsub(/"/, '\\"')}"}
+      end
+    end
+
+    def unparse_pair(k, v)
+      v = v.call if v.is_a?(Proc)
+      # only quote strings if they include whitespace
+      if v == nil
+        nil
+      elsif v == true
+        k
+      elsif v.is_a?(Float)
+        "#{k}=#{format("%.3f", v)}"
+      elsif v.is_a?(String) && v =~ /\s/
+        quote_string(k, v)
+      elsif v.is_a?(Time)
+        "#{k}=#{v.iso8601}"
+      else
+        "#{k}=#{v}"
+      end
+    end
+  end
+end

data/lib/jersey/logging/mixins.rb

@@ -0,0 +1,31 @@
+module Jersey
+  module Logging
+    # always log the time
+    module LogTime
+      def log(hash = {})
+        super(hash.merge(now: Time.now))
+      end
+    end
+    # only log the first ten lines of a backtrace so error logs
+    # are digestible
+    module LogError
+      def log(loggable = {})
+        case loggable
+        when Hash
+          super(loggable)
+        when Exception
+          e = loggable
+          super(error: true, id: e.object_id, message: e.message)
+          lineno = 0
+          e.backtrace[0,10].each do |line|
+            lineno += 1
+            super(error: true,
+                  id: e.object_id,
+                  backtrace: line,
+                  line_number: lineno)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jersey/middleware/request_id.rb

@@ -0,0 +1,46 @@
+require 'securerandom'
+
+module Jersey::Middleware
+  class RequestID
+    UUID_PATTERN =
+      /\A[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\Z/
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request_ids = [SecureRandom.uuid] + extract_request_ids(env)
+
+      # make ID of the request accessible to consumers down the stack
+      env["REQUEST_ID"] = request_ids[0]
+      RequestStore[:log] ||= {}
+      RequestStore[:log][:request_id] = request_ids[0]
+
+      # Extract request IDs from incoming headers as well. Can be used for
+      # identifying a request across a number of components in SOA.
+      env["REQUEST_IDS"] = request_ids
+
+      status, headers, response = @app.call(env)
+
+      # tag all responses with a request ID
+      headers["Request-Id"] = request_ids[0]
+
+      [status, headers, response]
+    ensure
+      RequestStore[:log].delete(:request_id)
+    end
+
+    private
+
+    def extract_request_ids(env)
+      request_ids = []
+      if env["HTTP_REQUEST_ID"]
+        request_ids = env["HTTP_REQUEST_ID"].split(",")
+        request_ids.map! { |id| id.strip }
+        request_ids.select! { |id| id =~ UUID_PATTERN }
+      end
+      request_ids
+    end
+  end
+end

data/lib/jersey/middleware/request_logger.rb

@@ -0,0 +1,38 @@
+module Jersey::Middleware
+  # Logs request info using the configured logger or the Jersey singleton
+  #
+  # Adds request_id to the default logger params
+  class RequestLogger
+    def initialize(app, options={})
+      @app = app
+      @logger = options[:logger] || Jersey.logger
+    end
+
+    def call(env)
+      @request_start = Time.now
+      request = Rack::Request.new(env)
+      start_data = {
+        at:              "start",
+        request_id:      env['REQUEST_ID'],
+        method:          request.request_method,
+        path:            request.path_info,
+        content_type:    request.content_type,
+        content_length:  request.content_length
+      }
+      @logger.log(start_data)
+      status, headers, response = @app.call(env)
+      @logger.log(
+        at:              "finish",
+        method:          request.request_method,
+        path:            request.path_info,
+        status:          status,
+        content_length:  headers['Content-Length'],
+        route_signature: env['ROUTE_SIGNATURE'],
+        elapsed:         (Time.now - @request_start).to_f,
+        request_id:      env['REQUEST_ID']
+      )
+      @logger.reset!(:request_id)
+      [status, headers, response]
+    end
+  end
+end

data/lib/jersey/setup.rb

@@ -0,0 +1,40 @@
+require 'env-conf'
+
+module Jersey
+  #require bundler and the proper gems for the ENV
+  def self.require
+    Kernel.require 'bundler'
+    Config.dotenv!
+    $stderr.puts "Loading #{Config.app_env} environment..."
+    Bundler.require(:default, Config.app_env)
+  end
+
+  # adds ./lib dir to the load path
+  def self.load_path
+    $stderr.puts "Adding './lib' to path..."
+    $LOAD_PATH.unshift(File.expand_path('./lib'))
+  end
+
+  # sets TZ to UTC and Sequel timezone to :utc
+  def self.set_timezones
+    $stderr.puts "Setting timezones to UTC..."
+    Sequel.default_timezone = :utc if defined? Sequel
+    ENV['TZ'] = 'UTC'
+  end
+
+  def self.hack_time_class
+    $stderr.puts "Modifying Time#to_s to use #iso8601..." if ENV['DEBUG']
+    # use send to call private method
+    Time.send(:define_method, :to_s) do
+      self.iso8601
+    end
+  end
+
+  # all in one go
+  def self.setup
+    self.require
+    self.load_path
+    self.set_timezones
+    self.hack_time_class
+  end
+end

data/lib/jersey/time.rb

@@ -0,0 +1,29 @@
+class Time
+  def last_month
+    (self.to_datetime << 1).to_time
+  end
+
+  def next_month
+    (self.to_datetime >> 1).to_time
+  end
+
+  def tomorrow
+    (self.to_datetime + 1).to_time
+  end
+
+  def yesterday
+    (self.to_datetime - 1).to_time
+  end
+end
+
+class Fixnum
+  def weeks
+    self.days * 7
+  end
+  alias :week :weeks
+
+  def days
+    self * 24 * 60 * 60
+  end
+  alias :day :days
+end

data/lib/jersey/version.rb

@@ -0,0 +1,3 @@
+module Jersey
+  VERSION = "0.0.3"
+end

data/test/errors_test.rb

@@ -0,0 +1,48 @@
+require_relative 'helper'
+
+class ErrorsTest < ApiTest
+  class SimpleApi < Jersey::API::Base
+    get '/test-409' do
+      raise Conflict, "bad"
+    end
+
+    get '/test-500' do
+      raise InternalServerError, "bad"
+    end
+
+    get '/test-runtime-error' do
+      raise "boom!"
+    end
+  end
+
+  def app
+    SimpleApi
+  end
+
+  def test_not_found
+    get '/not-found'
+    assert_equal(404, last_response.status)
+    assert_equal('NotFound', json['error']['type'])
+  end
+
+  def test_http_errors_409
+    get '/test-409'
+    assert_equal(409, last_response.status)
+    assert_equal('Conflict', json['error']['type'])
+    assert_equal('bad', json['error']['message'])
+  end
+
+  def test_http_errors_500
+    get '/test-500'
+    assert_equal(500, last_response.status)
+    assert_equal('InternalServerError', json['error']['type'])
+    assert_equal('bad', json['error']['message'])
+  end
+
+  def test_http_errors_Undefined
+    get '/test-runtime-error'
+    assert_equal(500, last_response.status)
+    assert_equal('RuntimeError', json['error']['type'])
+    assert_equal('boom!', json['error']['message'])
+  end
+end