lamby_updated 5.2.1

data/lib/lamby/handler.rb

@@ -0,0 +1,137 @@
+module Lamby
+  class Handler
+
+    class << self
+
+      def call(app, event, context, options = {})
+        Lamby::ColdStartMetrics.instrument! if Lamby.config.cold_start_metrics?
+        new(app, event, context, options).call.response
+      end
+
+    end
+
+    def initialize(app, event, context, options = {})
+      @app = app
+      @event = event
+      @context = context
+      @options = options
+    end
+
+    def response
+      @response
+    end
+
+    def status
+      @status
+    end
+
+    def headers
+      @headers
+    end
+
+    def set_cookies
+      return @set_cookies if defined?(@set_cookies)
+      @set_cookies = if @headers && @headers['Set-Cookie']
+        @headers.delete('Set-Cookie').split("\n")
+      end
+    end
+
+    def body
+      @rbody ||= ''.tap do |rbody|
+        @body.each { |part| rbody << part if part }
+        @body.close if @body.respond_to? :close
+      end
+    end
+
+    def call
+      @response ||= call_app
+      self
+    end
+
+    def base64_encodeable?(hdrs = @headers)
+      hdrs && (
+        hdrs['Content-Transfer-Encoding'] == 'binary' ||
+        content_encoding_compressed?(hdrs) ||
+        hdrs['X-Lamby-Base64'] == '1'
+      )
+    end
+
+    def body64
+      Base64.strict_encode64(body)
+    end
+
+    private
+
+    def rack
+      return @rack if defined?(@rack)
+      @rack = begin
+        type = rack_option
+        klass = Lamby::Rack.lookup type, @event
+        (klass && klass.handle?(@event)) ? klass.new(@event, @context) : false
+      end
+    end
+
+    def rack_option
+      return if ENV['LAMBY_TEST_DYNAMIC_HANDLER']
+      @options[:rack]
+    end
+
+    def rack_response
+      { statusCode: status,
+        headers: headers,
+        body: body }.merge(rack.response(self))
+    end
+
+
+    def call_app
+      retries ||= 0
+      if Debug.on?(@event)
+        Debug.call @event, @context, rack.env
+      elsif rack?
+        @status, @headers, @body = @app.call rack.env 
+        set_cookies
+        rack_response
+      elsif lambdakiq?
+        Lambdakiq.cmd event: @event, context: @context
+      elsif lambda_cable?
+        LambdaCable.cmd event: @event, context: @context
+      elsif LambdaConsole.handle?(@event)
+        LambdaConsole.handle(@event)
+      elsif event_bridge?
+        Lamby.config.event_bridge_handler.call @event, @context
+      else
+        [404, {}, StringIO.new('')]
+      end
+    rescue ActiveRecord::ConnectionNotEstablished => e
+      retries += 1
+      if retries < 3
+        sleep(2 ** retries) # Exponential backoff
+        retry
+      else
+        raise e
+      end
+    end
+
+    def content_encoding_compressed?(hdrs)
+      content_encoding_header = hdrs['Content-Encoding'] || ''
+      content_encoding_header.split(', ').any? { |h| ['br', 'gzip'].include?(h) }
+    end
+
+    def rack?
+      rack
+    end
+
+    def event_bridge?
+      Lamby.config.event_bridge_handler &&
+        @event.key?('source') && @event.key?('detail') && @event.key?('detail-type')
+    end
+
+    def lambdakiq?
+      defined?(::Lambdakiq) && ::Lambdakiq.jobs?(@event)
+    end
+
+    def lambda_cable?
+      defined?(::LambdaCable) && ::LambdaCable.handle?(@event, @context)
+    end
+  end
+end

data/lib/lamby/logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+if ENV['AWS_EXECUTION_ENV']
+  ENV['RAILS_LOG_TO_STDOUT'] = '1' 
+
+  module Lamby
+    module Logger
+
+      def initialize(*args, **kwargs)
+        args[0] = STDOUT
+        super(*args, **kwargs)
+      end
+
+    end
+  end
+
+  Logger.prepend Lamby::Logger unless ENV['LAMBY_TEST']
+end

data/lib/lamby/proxy_context.rb

@@ -0,0 +1,25 @@
+module Lamby
+  # This class is used by the `lamby:proxy_server` Rake task to run a
+  # Rack server for local development proxy. Specifically, this class 
+  # accepts a JSON respresentation of a Lambda context object converted 
+  # to a Hash as the single arugment.
+  # 
+  class ProxyContext
+    def initialize(data)
+      @data = data
+    end
+
+    def method_missing(method_name, *args, &block)
+      key = method_name.to_s
+      if @data.key?(key)
+        @data[key]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @data.key?(method_name.to_s) || super
+    end
+  end
+end

data/lib/lamby/proxy_server.rb

@@ -0,0 +1,36 @@
+module Lamby
+  class ProxyServer
+    
+    METHOD_NOT_ALLOWED = <<-HEREDOC.strip
+      <h1>Method Not Allowed</h1>
+      <p>Please POST to this endpoint with an application/json content type and JSON payload of your Lambda's event and context.<p>
+      <p>Example: <code>{ "event": event, "context": context }</code></p>
+    HEREDOC
+    
+    def call(env)
+      return method_not_allowed unless method_allowed?(env)
+      event, context = event_and_context(env)
+      lambda_to_rack Lamby.cmd(event: event, context: context)
+    end
+
+    private
+
+    def event_and_context(env)
+      data = env['rack.input'].dup.read
+      json = JSON.parse(data)
+      [ json['event'], Lamby::ProxyContext.new(json['context']) ]
+    end
+
+    def method_allowed?(env)
+      env['REQUEST_METHOD'] == 'POST' && env['CONTENT_TYPE'] == 'application/json'
+    end
+
+    def method_not_allowed
+      [405, {"Content-Type" => "text/html"}, [ METHOD_NOT_ALLOWED.dup ]]
+    end
+
+    def lambda_to_rack(response)
+      [ 200, {"Content-Type" => "application/json"}, [ response.to_json ] ]
+    end
+  end
+end

data/lib/lamby/rack.rb

@@ -0,0 +1,115 @@
+module Lamby
+  class Rack
+    LAMBDA_EVENT = 'lambda.event'.freeze
+    LAMBDA_CONTEXT = 'lambda.context'.freeze
+    HTTP_X_REQUESTID = 'HTTP_X_REQUEST_ID'.freeze
+    HTTP_X_REQUEST_START = 'HTTP_X_REQUEST_START'.freeze
+    HTTP_COOKIE = 'HTTP_COOKIE'.freeze
+    
+    class << self
+
+      def lookup(type, event)
+        types[type] || types.values.detect { |t| t.handle?(event) }
+      end
+
+      # Order is important. REST is hardest to isolated with handle? method.
+      def types
+        { alb:  RackAlb,
+          http: RackHttp,
+          rest: RackRest,
+          api:  RackRest }
+      end
+
+    end
+
+    attr_reader :event, :context
+
+    def initialize(event, context)
+      @event = event
+      @context = context
+    end
+
+    def env
+      @env ||= env_base.merge!(env_headers)
+    end
+
+    def response(_handler)
+      {}
+    end
+
+    def multi_value?
+      false
+    end
+
+    private
+
+    def env_base
+      raise NotImplementedError
+    end
+
+    def env_headers
+      headers.transform_keys do |key|
+        "HTTP_#{key.to_s.upcase.tr '-', '_'}"
+      end.tap do |hdrs|
+        hdrs[HTTP_X_REQUESTID] = request_id
+        hdrs[HTTP_X_REQUEST_START] = "t=#{request_start}" if request_start
+      end
+    end
+
+    def content_type
+      headers.delete('Content-Type') || headers.delete('content-type') || headers.delete('CONTENT_TYPE')
+    end
+
+    def content_length
+      bytesize = body.bytesize.to_s if body
+      headers.delete('Content-Length') || headers.delete('content-length') || headers.delete('CONTENT_LENGTH') || bytesize
+    end
+
+    def body
+      @body ||= if event['body'] && base64_encoded?
+        Base64.decode64 event['body']
+      else
+        event['body']
+      end
+    end
+
+    def headers
+      @headers ||= event['headers'] || {}
+    end
+
+    def query_string
+      @query_string ||= if event.key?('rawQueryString')
+        event['rawQueryString']
+      elsif event.key?('multiValueQueryStringParameters')
+        query = event['multiValueQueryStringParameters'] || {}
+        query.map do |key, value|
+          value.map{ |v| "#{key}=#{v}" }.join('&')
+        end.flatten.join('&')
+      else
+        build_query_string
+      end
+    end
+
+    def build_query_string
+      return if event['queryStringParameters'].nil?
+      ::Rack::Utils.build_nested_query(
+        event.fetch('queryStringParameters')
+      ).gsub('[', '%5B')
+       .gsub(']', '%5D')
+    end
+
+    def base64_encoded?
+      event['isBase64Encoded']
+    end
+
+    def request_id
+      context.aws_request_id
+    end
+
+    def request_start
+      event.dig('requestContext', 'timeEpoch') || 
+        event.dig('requestContext', 'requestTimeEpoch')
+    end
+
+  end
+end

data/lib/lamby/rack_alb.rb

@@ -0,0 +1,82 @@
+module Lamby
+  class RackAlb < Lamby::Rack
+
+    class << self
+
+      def handle?(event)
+        event.key?('httpMethod') && 
+          event.dig('requestContext', 'elb')
+      end
+
+    end
+
+    def alb?
+      true
+    end
+
+    def multi_value?
+      event.key? 'multiValueHeaders'
+    end
+
+    def response(handler)
+      hhdrs = handler.headers
+      if multi_value?
+        multivalue_headers = hhdrs.transform_values { |v| Array[v].compact.flatten }
+        multivalue_headers['Set-Cookie'] = handler.set_cookies if handler.set_cookies
+      end
+      status_description = "#{handler.status} #{::Rack::Utils::HTTP_STATUS_CODES[handler.status]}"
+      base64_encode = handler.base64_encodeable?(hhdrs)
+      body = Base64.strict_encode64(handler.body) if base64_encode
+      { multiValueHeaders: multivalue_headers,
+        statusDescription: status_description,
+        isBase64Encoded: base64_encode,
+        body: body }.compact
+    end
+
+    private
+
+    def env_base
+      { ::Rack::REQUEST_METHOD => event['httpMethod'],
+        ::Rack::SCRIPT_NAME => '',
+        ::Rack::PATH_INFO => event['path'] || '',
+        ::Rack::QUERY_STRING => query_string,
+        ::Rack::SERVER_NAME => headers['host'],
+        ::Rack::SERVER_PORT => headers['x-forwarded-port'],
+        ::Rack::SERVER_PROTOCOL => 'HTTP/1.1',
+        ::Rack::RACK_VERSION => ::Rack::VERSION,
+        ::Rack::RACK_URL_SCHEME => headers['x-forwarded-proto'],
+        ::Rack::RACK_INPUT => StringIO.new(body || ''),
+        ::Rack::RACK_ERRORS => $stderr,
+        ::Rack::RACK_MULTITHREAD => false,
+        ::Rack::RACK_MULTIPROCESS => false,
+        ::Rack::RACK_RUNONCE => false,
+        LAMBDA_EVENT => event,
+        LAMBDA_CONTEXT => context
+      }.tap do |env|
+        ct = content_type
+        cl = content_length
+        env['CONTENT_TYPE'] = ct if ct
+        env['CONTENT_LENGTH'] = cl if cl
+      end
+    end
+
+    def headers
+      @headers ||= multi_value? ? headers_multi : super
+    end
+
+    def headers_multi
+      Hash[(event['multiValueHeaders'] || {}).map do |k,v|
+        if v.is_a?(Array)
+          if k == 'x-forwarded-for'
+            [k, v.join(', ')]
+          else
+            [k, v.first]
+          end
+        else
+          [k,v]
+        end
+      end]
+    end
+
+  end
+end

data/lib/lamby/rack_http.rb

@@ -0,0 +1,107 @@
+module Lamby
+  class RackHttp < Lamby::Rack
+
+    class << self
+
+      def handle?(event)
+        event.key?('version') && 
+          ( event.dig('requestContext', 'http') || 
+            event.dig('requestContext', 'httpMethod') )
+      end
+
+    end
+
+    def response(handler)
+      if handler.base64_encodeable?
+        { isBase64Encoded: true, body: handler.body64 }
+      else
+        super
+      end.tap do |r|
+        if cookies = handler.set_cookies
+          if payload_version_one?
+            r[:multiValueHeaders] ||= {}
+            r[:multiValueHeaders]['Set-Cookie'] = cookies
+          else
+            r[:cookies] = cookies
+          end
+        end
+      end
+    end
+
+    private
+
+    def env_base
+      { ::Rack::REQUEST_METHOD => request_method,
+        ::Rack::SCRIPT_NAME => '',
+        ::Rack::PATH_INFO => path_info,
+        ::Rack::QUERY_STRING => query_string,
+        ::Rack::SERVER_NAME => server_name,
+        ::Rack::SERVER_PORT => server_port,
+        ::Rack::SERVER_PROTOCOL => server_protocol,
+        ::Rack::RACK_VERSION => ::Rack::VERSION,
+        ::Rack::RACK_URL_SCHEME => 'https',
+        ::Rack::RACK_INPUT => StringIO.new(body || ''),
+        ::Rack::RACK_ERRORS => $stderr,
+        ::Rack::RACK_MULTITHREAD => false,
+        ::Rack::RACK_MULTIPROCESS => false,
+        ::Rack::RACK_RUNONCE => false,
+        LAMBDA_EVENT => event,
+        LAMBDA_CONTEXT => context
+      }.tap do |env|
+        ct = content_type
+        cl = content_length
+        env['CONTENT_TYPE'] = ct if ct
+        env['CONTENT_LENGTH'] = cl if cl
+      end
+    end
+
+    def env_headers
+      super.tap do |hdrs|
+        if cookies.any?
+          hdrs[HTTP_COOKIE] = cookies.join('; ')
+        end
+      end
+    end
+
+    def request_method
+      event.dig('requestContext', 'http', 'method') || event['httpMethod']
+    end
+
+    def cookies
+      event['cookies'] || []
+    end
+
+    # Using custom domain names with v1.0 yields a good `path` parameter sans
+    # stage. However, v2.0 and others do not. So we are just going to remove stage
+    # no matter waht from other places for both.
+    #
+    def path_info
+      stage = event.dig('requestContext', 'stage')
+      spath = event.dig('requestContext', 'http', 'path') || event.dig('requestContext', 'path')
+      spath = event['rawPath'] if spath != event['rawPath'] && !payload_version_one?
+      spath.sub /\A\/#{stage}/, ''
+    end
+
+    def server_name
+      headers['x-forwarded-host'] ||
+        headers['X-Forwarded-Host'] ||
+        headers['host'] ||
+        headers['Host']
+    end
+
+    def server_port
+      headers['x-forwarded-port'] || headers['X-Forwarded-Port']
+    end
+
+    def server_protocol
+      event.dig('requestContext', 'http', 'protocol') ||
+        event.dig('requestContext', 'protocol') ||
+        'HTTP/1.1'
+    end
+
+    def payload_version_one?
+      event['version'] == '1.0'
+    end
+
+  end
+end

data/lib/lamby/rack_rest.rb

@@ -0,0 +1,53 @@
+module Lamby
+  class RackRest < Lamby::Rack
+    
+    class << self
+
+      def handle?(event)
+        event.key?('httpMethod')
+      end
+
+    end
+
+    def response(handler)
+      if handler.base64_encodeable?
+        { isBase64Encoded: true, body: handler.body64 }
+      else
+        super
+      end.tap do |r|
+        if cookies = handler.set_cookies
+          r[:multiValueHeaders] ||= {}
+          r[:multiValueHeaders]['Set-Cookie'] = cookies
+        end
+      end
+    end
+
+    private
+
+    def env_base
+      { ::Rack::REQUEST_METHOD => event['httpMethod'],
+        ::Rack::SCRIPT_NAME => '',
+        ::Rack::PATH_INFO => event['path'] || '',
+        ::Rack::QUERY_STRING => query_string,
+        ::Rack::SERVER_NAME => headers['Host'],
+        ::Rack::SERVER_PORT => headers['X-Forwarded-Port'],
+        ::Rack::SERVER_PROTOCOL => event.dig('requestContext', 'protocol') || 'HTTP/1.1',
+        ::Rack::RACK_VERSION => ::Rack::VERSION,
+        ::Rack::RACK_URL_SCHEME => 'https',
+        ::Rack::RACK_INPUT => StringIO.new(body || ''),
+        ::Rack::RACK_ERRORS => $stderr,
+        ::Rack::RACK_MULTITHREAD => false,
+        ::Rack::RACK_MULTIPROCESS => false,
+        ::Rack::RACK_RUNONCE => false,
+        LAMBDA_EVENT => event,
+        LAMBDA_CONTEXT => context
+      }.tap do |env|
+        ct = content_type
+        cl = content_length
+        env['CONTENT_TYPE'] = ct if ct
+        env['CONTENT_LENGTH'] = cl if cl
+      end
+    end
+
+  end
+end

data/lib/lamby/railtie.rb

@@ -0,0 +1,9 @@
+module Lamby
+  class Railtie < ::Rails::Railtie
+    config.lamby = Lamby::Config.config
+
+    rake_tasks do
+      load 'lamby/tasks.rake'
+    end
+  end
+end