lamby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c73918d04cbb3595e6894ba9d15a3c15199fb01aa4eab940d4985b057e234d59
-  data.tar.gz: 25e3a650683c3d3f5a5a30364370b60c29c40e868dc4e93aad1766e94d3aaefb
+  metadata.gz: 2da2381e04438228fa63901ffd863bc2d1f97bf84e834cb57d40fc8d2353fc4e
+  data.tar.gz: 8bd9e4a546114e937fc3da4efa0fddd1e5d0800e5b757145662ac0d7e3c603e1
 SHA512:
-  metadata.gz: f712aaaba4fbe4bc44cdd238084d2049c98f09a3ccfe7df97f66f272b4e5bc7dcd4babe93f22beff16cc0a43c1b4f53d92bc2090ff8460f55eab3bc52465291b
-  data.tar.gz: 597c37b84b04dcd00be778f339fac9f0709afb94d14cb7111308f56de6a892e55bf3a022c34dec2900b4ce9f4f53f3b83ba71f365408bc6493e846b5009ea496
+  metadata.gz: ff7c934023c0237523b96cf5ebb374d3866c4eecadc3790615fc783e8f93db32ebf99b7c3c96b309debab0eaff54f8e5e1680d8e58bdbc67c3a96d954fe9fdb5
+  data.tar.gz: c9ea5922cd3e329b0b4665d0a7a45c2d0f8155a7cb25928ba35ea719d81511465263b94ee195b8b378761460c2fdba84d03fc42444f2ed92a573b04b8387a81f

data/.gitignore

@@ -2,7 +2,6 @@
 /.yardoc
 /_yardoc/
 /coverage/
-/doc/
 /pkg/
 /spec/reports/
 /tmp/

data/Gemfile.lock

@@ -1,13 +1,27 @@
 PATH
   remote: .
   specs:
-    lamby (0.1.0)
+    lamby (0.2.0)
+      activesupport
+      rack
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (5.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    concurrent-ruby (1.1.4)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
     minitest (5.11.3)
+    rack (2.0.6)
     rake (12.3.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby

data/README.md

@@ -1,42 +1,373 @@
+
 # Lamby
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lamby`. To experiment with that code, run `bin/console` for an interactive prompt.
+<img src="https://git.io/fhjSv" alt="Lamby: Simple Rails & AWS Lambda Integration using Rack." align="right" /><h3>Simple Rails & AWS Lambda Integration using Rack</h3>
+
+The goal of this project is to provide minimal code along with comprehensive documentation to get your Rails application running under AWS Lambda.
+
+This gem's code will focus mainly on converting API Gateway `event` and `context` objects into a Rack `env` to send to your Rails application. Most everything else is documentation. Please use the table of contents below to quickly navigate to any guides that interests you the most.
+
+### Table of Contents
+
+* [How Does Lamby Work?](#how-does-lamby-work)
+* [Getting Started](#getting-started)
+* [Installing AWS CLI and AWS SAM](#installing-aws-cli-and-aws-sam)
+* [Bin Script Conventions](#bin-script-conventions)
+* [SAM Bugs and Patches](#sam-bugs-and-patches)
+* [About AWS SAM and CloudFormation](#about-aws-sam-and-cloudformation)
+* [Performance](#performance)
+* [Database Connections](#database-connections)
+* [Basic Ruby and Lambda](#basic-ruby-and-lambda)
+* [Contributing](#contributing)
+* [Code of Conduct](#code-of-conduct)
+
+The following are code and/or documentation items we are currently working on. Please open an issue and suggest a new one if you do not see it here. Thanks!
+
+* [ ] Ensure Rack integration is solid and high quality.
+  - Cookies, Sessions, Query Params, Forms, etc.
+* [ ] Encrypted Session Secret via AWS System Manager Parameter Store.
+* [ ] Better Gemfile usage for development and/or test groups.
+* [ ] Hooking up Rails asset precompile to a S3 bucket and using an asset host.
+* [ ] Ensure Rails tagged UUID logging matches APIGateway/Lambda IDs in CloudWatch.
+* [ ] Documentation around using ImageMagick and Lambda Layers.
+  - https://twitter.com/clare_liguori/status/1087861037712400385
+  - https://github.com/mthenw/awesome-layers
+* [ ] Explore how New Relic could be used if at all.
+* [ ] Add `isBase64Encoded` to response as needed.
+* [ ] Better Railtie hooks, and gem structure. Tests.
+
+
+## How Does Lamby Work?
+
+Since [Rails is on Rack](https://guides.rubyonrails.org/rails_on_rack.html), the Lamby gem relies on converting API Gateway events sent to your `handler` and converting them to a [Rack](https://rack.github.io) `env` object. We then send that object to your application and pass the result back to the Lambda handler which expects a simple object/hash containing the `statusCode`, `body`, and `headers`. It is that simple.
+
+Thanks to the projects and people below which inspired our code and implementation strategies.
+
+* [AWS Sinatra Example](https://github.com/aws-samples/serverless-sinatra-sample)
+* [Rack Lambda Handler Pull Request](https://github.com/rack/rack/pull/1337)
+* [Serverless Rack Plugin](https://github.com/logandk/serverless-rack)
+* [Jets' Rack Implementation](https://github.com/tongueroo/jets/blob/master/lib/jets/controller/rack/env.rb)
+
+Other small details which Lamby helps with.
+
+* Ensure all `Logger` objects use `STDOUT`.
+* Sets the `RAILS_LOG_TO_STDOUT` environment variable.
+* Provides a debug response in development (or when `LAMBY_DEBUG` env set) using `?debug=1` query param.
+
 
-TODO: Delete this and the text above, and describe your gem
+## Getting Started
 
-## Installation
+ℹ️ Some of these steps may be automated once we learn they are worth automating.
 
-Add this line to your application's Gemfile:
+#### New Basic Rails Application Example
+
+Assuming you have a basic Rails application, or maybe you want to make a new one from scratch.
+
+```shell
+$ gem install rails
+$ rails new my_app \
+  --skip-active-record \
+  --skip-action-mailer \
+  --skip-active-storage \
+  --skip-action-cable \
+  --skip-spring \
+  --skip-coffee \
+  --skip-turbolinks \
+  --skip-bootsnap
+$ cd my_app
+$ rbenv local 2.5.3
+```
+
+#### Add The Gem
+
+Add the Lamby gem to your Rails project's `Gemfile`.
 
 ```ruby
 gem 'lamby'
 ```
 
-And then execute:
+#### Create Handler
+
+Create an `app.rb` file that will be the source for the Lambda's handler. Example:
+
+```ruby
+ENV['SECRET_KEY_BASE'] = '...' # Temporary hack, see TODO list above.
+require_relative 'config/boot'
+require 'lamby'
+require_relative 'config/application'
+require_relative 'config/environment'
+
+$app = Rack::Builder.new { run Rails.application }.to_app
+
+def handler(event:, context:)
+  Lamby.handler $app, event, context
+end
+```
+
+#### Create SAM Template
+
+Create an [AWS SAM](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md) `template.yaml` file that expresses your function's resources and how it receives events from API Gateway. Please use this full [doc/template.yaml](doc/template.yaml) file hosted here as a starting point. The basic template accomplishes the following.
 
-    $ bundle
+* Defines a `RailsEnv` input parameter.
+  - Applies this to the `RAILS_ENV` environment variable.
+* Creates a API Gateway resource named `RailsApi`.
+  - Ensures that the stage name is set to the Rails env.
+  - Using inline Swagger, define a root `/` via GET and greedy proxy `/{resource+}` via ANY.
+  - Allow any binary media type to be a valid response.
+* Creates a Lambda function resource named `RailsFunction`.
+  - Sets the handler to `app.handler`. File above.
+  - Defines events from API above for both root and greedy proxy.
+* Simple `Outputs` that echos the resources you created.
 
-Or install it yourself as:
+#### Git Ignores
 
-    $ gem install lamby
+Ensure both `/.aws-sam` and `/vendor/bundle` are added to `.gitignore`. AWS SAM uses the `.aws-sam` directory to build your project. No file there should be committed to source control.
 
-## Usage
+```shell
+$ echo '/.aws-sam' >> .gitignore
+$ echo '/vendor/bundle' >> .gitignore
+```
 
-TODO: Write usage instructions here
+#### Get Running
 
-## Development
+To run your Lambda locally or deploy it, please read the following sections:
+
+* [Installing AWS CLI and AWS SAM](#installing-aws-cli-and-aws-sam)
+* [Bin Script Conventions](#bin-script-conventions)
+
+
+## Installing AWS CLI and AWS SAM
+
+You will need both of these tools to run SAM locally and/or deploy your Lambda application to AWS. SAM also requires the usage of Docker.
+
+* [Install SAM CLI](https://aws.amazon.com/serverless/sam/)
+* [Installing the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)
+* [Install Docker](https://docs.docker.com/install/)
+
+
+## Bin Script Conventions
+
+Below is a list of bin scripts we recommend creating for your AWS SAM & Rails projects. Each section contains a short description on what the script does. Remember, think of these scripts as starting points! You should add to or adjust each to meet your needs while following [Strap](https://github.com/MikeMcQuaid/strap) and [Scripts to Rule Them All](https://githubengineering.com/scripts-to-rule-them-all/) conventions.
+
+#### bin/bootstrap
+
+The current Docker image for Lambda's Ruby runtime is only compatible with Bundler prior to version 2.0.0. So this bootstrap makes sure the latest 1.x bundler is installed and used.
+
+```shell
+#!/bin/bash
+set -e
+
+gem uninstall -aIx bundler
+gem install bundler -v 1.17.3
+```
+
+#### bin/setup
+
+Nothing fancy here, just calling build where most of the work is done.
+
+```shell
+#!/bin/bash
+set -e
+
+./bin/build
+```
+
+#### bin/build
+
+This makes use of the [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) command along with the `--use-container` option to ensure gems with native extensions are built for both the AWS' Linux platform and your native host platform. It also:
+
+* Sets up a pristine build environment.
+* Removes unnecessary project files copied over during the build.
+* Cleans build directory's vendor gems of unwanted cache files. Saves ~40% [package size](https://docs.aws.amazon.com/lambda/latest/dg/limits.html).
+* Builds local platform gems on top of copied Linux platform gems.
+
+```shell
+#!/bin/bash
+set -e
+
+# Clean any previous bundle dir.
+rm -rf ./.bundle \
+  ./vendor/bundle \
+  ./.aws-sam/build \
+  node_modules
+
+# Clean up Rails
+./bin/rails log:clear tmp:clear
+
+# Ensure native extensions built for platform.
+sam build --use-container
+
+# Clean build dir of unneeded artifacts.
+pushd ./.aws-sam/build/RailsFunction/
+rm -rf .aws-sam \
+  .git \
+  node_modules \
+  test \
+  template.yaml \
+  package.json \
+  yarn.lock \
+  tmp
+rm -rf vendor/bundle/ruby/2.5.0/cache
+popd
+
+# Avoid doing local bundle work if building for deploy.
+if [ -z ${SKIP_LOCAL_BUNDLE+x} ]; then
+  # Copy the build bundle to allow server native extensions to work.
+  cp -R ./.aws-sam/build/RailsFunction/vendor/bundle ./vendor/bundle
+  # Make a comingled bundle dir for build and this platform.
+  rm -rf ./.bundle
+  bundle install --path vendor/bundle
+fi
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+#### bin/deploy
+
+Uses both the [sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html) and [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) commands to ship your Lambda stack to AWS. It also:
+
+* Uses or sets the `RAILS_ENV` variable. Defaults to `development`.
+* Uses or sets the `CF_BUCKET_NAME` variable. This is the name of the S3 bucket that holds your deploy artifacts.
+* Sets the `SKIP_LOCAL_BUNDLE` environment variable used by build.
+
+```shell
+#!/bin/bash
+set -e
+
+export RAILS_ENV=${RAILS_ENV:="development"}
+export CF_BUCKET_NAME=${CF_BUCKET_NAME:="mycloudformationbucket.example.org"}
+export SKIP_LOCAL_BUNDLE="1"
+
+./bin/build
+
+sam package \
+    --template-file ./.aws-sam/build/template.yaml \
+    --output-template-file ./.aws-sam/build/packaged.yaml \
+    --s3-bucket $CF_BUCKET_NAME \
+    --s3-prefix "my-app-${RAILS_ENV}"
+
+sam deploy \
+    --template-file ./.aws-sam/build/packaged.yaml \
+    --stack-name "my-app-${RAILS_ENV}" \
+    --capabilities "CAPABILITY_IAM" \
+    --parameter-overrides \
+      RailsEnv=${RAILS_ENV}
+```
+
+So an example `bin/deploy-production` script would look like this.
+
+```shell
+#!/bin/bash
+set -e
+
+export RAILS_ENV="production"
+
+./bin/deploy
+```
+
+#### bin/server
+
+Start the normal Rails development server. Make sure to run setup/build prior.
+
+```shell
+#!/bin/bash
+set -e
+
+./bin/rails server
+```
+
+#### bin/server-sam
+
+Uses the [sam local start-api](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-start-api.html) command to
+
+```shell
+#!/bin/bash
+set -e
+
+# Delete the static build to avoid local server using it.
+rm -rf ./.aws-sam/build
+sam local start-api
+```
+
+
+## SAM Bugs and Patches
+
+Unfortunately, the SAM CLI project has a few needed enhancements and if you decide to do any local development via the [sam local start-api](#binserver-sam) command, it will need to be patched on your local machine. I used the commands below to find the two files needing patching.
+
+```shell
+$ which sam # Use directory info below in find command.
+$ find /usr/local -name container.py | grep samcli
+$ find /usr/local -name local_apigw_service.py | grep samcli
+```
+
+Here are the issues we have created on the SAM CLI project. Details on the patches below.
+
+* [Add Docker Delegated Consistency to Volume](https://github.com/awslabs/aws-sam-cli/pull/1046)
+* [Missing Authentication Token for root path '/'](https://github.com/awslabs/aws-sam-cli/issues/437)
+
+#### Docker Volume Mount Performance on Mac
+
+If you are on a Mac, Docker has a [known performance issue](https://forums.docker.com/t/file-access-in-mounted-volumes-extremely-slow-cpu-bound/8076) when sharing volumes due to the overhead of keeping files in sync. This performance issue means your Rails application could take ~60 seconds to load in development. Thankfully, Docker has [tooling in place](https://docs.docker.com/docker-for-mac/osxfs-caching/) to help.
+
+Once you found the correct `container.py` file, make this change below to tell the Docker SDK to mount the volume with both the `ro` (read-only) option and `delegated` consistency mode.
+
+```diff
+@@ -95,7 +95,7 @@
+                     # https://docs.docker.com/storage/bind-mounts
+                     # Mount the host directory as "read only" inside container
+                     "bind": self._working_dir,
+-                    "mode": "ro"
++                    "mode": "ro,delegated"
+                 }
+             },
+             # We are not running an interactive shell here.
+```
+
+#### Fixing Root SAM Local Proxy Paths
+
+We need our API Gateway to use both a root path and a greedy proxy path to forward to Rails in development. SAM has a feature compatibility bug where it forces static file hosting on the root path. Once you found the correct `local_apigw_service.py` file, make the change below to disable static `public` directory assets on the root path. Don't worry, Rails & Rack will serve your static files automatically instead.
+
+```diff
+@@ -71,7 +71,7 @@
+         """
+
+         self._app = Flask(__name__,
+-                          static_url_path="",  # Mount static files at root '/'
++                          static_url_path=None,  # Mount static files at root '/'
+                           static_folder=self.static_dir  # Serve static files from this directory
+                           )
+```
+
+
+## About AWS SAM and CloudFormation
+
+AWS SAM is shorthand for the [Serverless Application Model](https://github.com/awslabs/serverless-application-model) and it is a superset of CloudFormation - a language that describes and provisions your infrastructure using code. As your application grows and requires additional AWS resources, learning how to express this in your `template.yml` is critical. We recommend the following links when needing to learn both SAM and CloudFormation.
+
+* [AWS Serverless Application Model (SAM)](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md)
+* [AWS CloudFormation User Guide](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)
+
+
+## Performance
+
+Because your Rails app is initialized outside the `handler` it should be loaded into memory and respond to requests in a very timely manner. Make sure to set the `MemorySize` as needed in your `template.yml` and you should get comparable performance to EC2. Initial tests show that basic view rendering only takes a few milliseconds. Please do share your performance results if you have any!
+
+
+## Database Connections
+
+If you want to use a database with Rails and Lambda, I would highly suggest using DynamoDB with the excellent [AWS Record](https://github.com/aws/aws-sdk-ruby-record) gem. However, if you want to explore and share how you might use Lamby with PG or MySQL, I'd love to hear about it.
+
+
+## Basic Ruby and Lambda
+
+Curious about using AWS SAM with Ruby and no Rails? Please see this 757rb (Norfolk Ruby User's Group) repository for an overview on how to kick-start your next Ruby project.
+
+* [Using Ruby with AWS Lambda & SAM](https://github.com/757rb/hello-757rb-lambda)
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/metaskills/lamby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+After checking out the repo, run `./bin/setup` to install dependencies. Then, run `./bin/test` to run the tests. **NOTE: There are no tests now but adding them is on our TODO list.**
 
-## License
+Bug reports and pull requests are welcome on GitHub at https://github.com/metaskills/lamby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 ## Code of Conduct
 

data/bin/setup

@@ -1,8 +1,7 @@
 #!/usr/bin/env bash
+
 set -euo pipefail
 IFS=$'\n\t'
 set -vx
 
 bundle install
-
-# Do any other automated setup that you need to do here

data/bin/test

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -e
+
+bundle exec rake test

data/doc/template.yml

@@ -0,0 +1,85 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Transform: AWS::Serverless-2016-10-31
+Description: Hello Rails Lambda
+
+Parameters:
+
+  RailsEnv:
+    Type: String
+    Default: development
+    AllowedValues:
+      - development
+      - test
+      - staging
+      - production
+
+Resources:
+
+  RailsApi:
+    Type: AWS::Serverless::Api
+    Properties:
+      StageName: !Ref RailsEnv
+      EndpointConfiguration: EDGE
+      DefinitionBody:
+        swagger: 2.0
+        info: { title: !Ref 'AWS::StackName' }
+        basePath: !Join [ '', [ '/', !Ref RailsEnv ] ]
+        schemes: [ 'https' ]
+        paths:
+          /:
+            get:
+              x-amazon-apigateway-integration:
+                uri:
+                  Fn::Sub: arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${RailsFunction.Arn}:live/invocations
+                httpMethod: POST
+                type: aws_proxy
+          /{resource+}:
+            x-amazon-apigateway-any-method:
+              parameters:
+                - name: resource
+                  in: path
+                  required: true
+                  type: string
+              x-amazon-apigateway-integration:
+                uri:
+                  Fn::Sub: arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${RailsFunction.Arn}:live/invocations
+                httpMethod: POST
+                type: aws_proxy
+        x-amazon-apigateway-binary-media-types:
+          - '*/*'
+
+  RailsFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      CodeUri: .
+      Handler: app.handler
+      Runtime: ruby2.5
+      MemorySize: 512
+      Timeout: 30
+      Environment:
+        Variables:
+          RAILS_ENV: !Ref RailsEnv
+      Events:
+        Root:
+          Type: Api
+          Properties:
+            Path: /
+            Method: GET
+            RestApiId: !Ref RailsApi
+        RailsAppAll:
+          Type: Api
+          Properties:
+            Path: /{resource+}
+            Method: ANY
+            RestApiId: !Ref RailsApi
+      AutoPublishAlias: live
+
+Outputs:
+
+  RailsApiUrl:
+    Description: API Gateway Endpoint
+    Value: !Sub "https://${RailsApi}.execute-api.${AWS::Region}.amazonaws.com/${RailsEnv}/"
+
+  RailsFunctionArn:
+    Description: Lambda Function ARN
+    Value: !GetAtt RailsFunction.Arn

data/lamby.gemspec

@@ -1,7 +1,7 @@
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "lamby/version"
+require 'lamby/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "lamby"
@@ -18,7 +18,9 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
+  spec.add_dependency 'rack'
+  spec.add_dependency 'activesupport'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
 end

data/lib/lamby.rb

@@ -1,6 +1,19 @@
-require "lamby/version"
+require 'lamby/logger'
+require 'rack'
+require 'base64'
+require 'active_support/all'
+require 'lamby/version'
+require 'lamby/sam_helpers'
+require 'lamby/rack'
+require 'lamby/debug'
+require 'lamby/handler'
 
 module Lamby
-  class Error < StandardError; end
-  # Your code goes here...
+
+  extend self
+
+  def handler(app, event, context)
+    Handler.call(app, event, context)
+  end
+
 end

data/lib/lamby/debug.rb

@@ -0,0 +1,46 @@
+module Lamby
+  module Debug
+    include Lamby::SamHelpers
+
+    extend self
+
+    def on?(event)
+      params = event['queryStringParameters']
+      (Rails.env.development? || ENV['LAMBY_DEBUG']) && params && params['debug'] == '1'
+    end
+
+    def call(event, context, env)
+      [ 200, { 'Content-Type' => 'text/html' }, [body(event, context, env)] ]
+    end
+
+    private
+
+    def body(event, context, env)
+      <<-HTML
+        <!DOCTYPE html>
+        <html>
+          <body>
+            <h1>Lamby Debug Response</h1>
+            <h2>Event</h2>
+            <pre>
+              #{JSON.pretty_generate(event)}
+            </pre>
+            <h2>Rack Env</h2>
+            <pre>
+              #{JSON.pretty_generate(env)}
+            </pre>
+            <h2>#{context.class.name}</h2>
+            <code>
+              #{CGI::escapeHTML(context.inspect)}
+            </code>
+            <h2>Environment</h2>
+            <pre>
+              #{sam_local? ? JSON.pretty_generate(ENV.to_h) : 'N/A'}
+            </pre>
+          </body>
+        </html>
+      HTML
+    end
+
+  end
+end

data/lib/lamby/handler.rb

@@ -0,0 +1,58 @@
+module Lamby
+  class Handler
+
+    class << self
+
+      def call(app, event, context)
+        new(app, event, context).call.response
+      end
+
+    end
+
+    def initialize(app, event, context)
+      @app = app
+      @event = event
+      @context = context
+      @rack = Lamby::Rack.new event, context
+      @called = false
+    end
+
+    def response
+      { statusCode: status,
+        headers: headers,
+        body: body }
+    end
+
+    def status
+      @status
+    end
+
+    def headers
+      @headers
+    end
+
+    def body
+      @rbody ||= ''.tap do |rbody|
+        @body.each { |part| rbody << part }
+      end
+    end
+
+    def call
+      return self if @called
+      @status, @headers, @body = call_app
+      @called = true
+      self
+    end
+
+    private
+
+    def call_app
+      if Debug.on?(@event)
+        Debug.call @event, @context, @rack.env
+      else
+        @app.call @rack.env
+      end
+    end
+
+  end
+end

data/lib/lamby/logger.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+ENV['RAILS_LOG_TO_STDOUT'] = '1'
+
+module Lamby
+  module Logger
+
+    def initialize(*args)
+      args[0] = STDOUT
+      super(*args)
+    end
+
+  end
+end
+
+Logger.prepend Lamby::Logger
+
+# TODO: Railtie initializer
+# Rails.application.config.logger = ActiveSupport::TaggedLogging.new(
+#   ActiveSupport::Logger.new(STDOUT).tap { |logger|
+#     logger.formatter = Rails.application.config.log_formatter
+#   }
+# )

data/lib/lamby/rack.rb

@@ -0,0 +1,88 @@
+module Lamby
+  class Rack
+
+    include SamHelpers
+
+    LAMBDA_EVENT = 'lambda.event'.freeze
+    LAMBDA_CONTEXT = 'lambda.context'.freeze
+    HTTP_X_APIGWSTAGE = 'HTTP_X_APIGWSTAGE'.freeze
+
+    attr_reader :event, :context
+
+    def initialize(event, context)
+      @event = event
+      @context = context
+    end
+
+    def env
+      @env ||= env_base.merge!(env_headers)
+    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 => 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[::Rack::CONTENT_TYPE] = ct if ct
+        env[::Rack::CONTENT_LENGTH] = cl if cl
+      end
+    end
+
+    def env_headers
+      headers.transform_keys do |key|
+        "HTTP_#{key.to_s.upcase.tr '-', '_'}"
+      end
+    end
+
+    def 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') || bytesize
+    end
+
+    def body
+      @body ||= if event['body'] && base64_encoded?
+        Base64.decode64 event['body']
+      else
+        event['body']
+      end
+    end
+
+    def headers
+      event['headers'] || {}
+    end
+
+    def query_string
+      @query_string ||= event['queryStringParameters'].try(:to_query)
+    end
+
+    def base64_encoded?
+      event['isBase64Encoded']
+    end
+
+    def server_protocol
+      event.dig('requestContext', 'protocol') || 'HTTP/1.1'
+    end
+
+  end
+end

data/lib/lamby/sam_helpers.rb

@@ -0,0 +1,9 @@
+module Lamby
+  module SamHelpers
+
+    def sam_local?
+      ENV['AWS_SAM_LOCAL'] == 'true'
+    end
+
+  end
+end

data/lib/lamby/version.rb

@@ -1,3 +1,3 @@
 module Lamby
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: lamby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ken Collins
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-10 00:00:00.000000000 Z
+date: 2019-03-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -70,8 +98,15 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/test
+- doc/template.yml
 - lamby.gemspec
 - lib/lamby.rb
+- lib/lamby/debug.rb
+- lib/lamby/handler.rb
+- lib/lamby/logger.rb
+- lib/lamby/rack.rb
+- lib/lamby/sam_helpers.rb
 - lib/lamby/version.rb
 homepage: https://github.com/customink/lamby
 licenses: