Write your AWS Lambda function handlers using a Rake-like declarative syntax:
# ./lambda_function.rb
require 'yake'
handler :lambda_handler do |event|
# Your code here
end
# Handler signature: `lambda_function.lambda_handler`You can even declare Sinatra-like API Gateway routes for a main entrypoint:
# ./lambda_function.rb
require 'yake/api'
header 'content-type' => 'application/json'
get '/fizz' do
respond 200, { ok: true }.to_json
end
handler :lambda_handler do |event|
route event
rescue => err
respond 500, { message: err.message }.to_json
end
# Handler signature: `lambda_function.lambda_handler`Add this line to your application's Gemfile:
gem 'yake'And then execute:
bundle installOr install it yourself as:
gem install yake"λ" + Rake, but "λ" is hard to type and I think "y" looks like a funny little upside-down-and-backwards Lambda symbol.
So why use yake for your Lambda functions?
By default, the handler function wraps its block in log lines formatted to match the style of Amazon's native Lambda logs sent to CloudWatch. Each invocation of the handler will log both the input event and the returned value, prefixed with the ID of the request:
START RequestId: 149c500f-028a-4b57-8977-0ef568cf8caf Version: $LATEST
INFO RequestId: 149c500f-028a-4b57-8977-0ef568cf8caf EVENT { … }
…
INFO RequestId: 149c500f-028a-4b57-8977-0ef568cf8caf RETURN { … }
END RequestId: 149c500f-028a-4b57-8977-0ef568cf8caf
REPORT RequestId: 149c500f-028a-4b57-8977-0ef568cf8caf Duration: 43.97 ms Billed Duration: 44 ms Memory Size: 128 MB Max Memory Used: 77 MB
Logging the request ID in this way makes gathering logs lines for a particular execution in CloudWatch much easier.
You can customize or disable the logger:
logging :off # disables logging entirely
logging pretty: false # Logs event/result in compact JSON
logging :on, MyLogger.new # Use a custom loggerInclude Yake::Logger on a class to access this logger:
class Fizz
include Yake::Logger
end
Fizz.new.logger == Yake.logger
# => trueA common use of Lambda functions is as a proxy for API Gateway. Oftentimes users will deploy a single Lambda function to handle all requests coming from API Gateway.
Requiring the yake/api module will add the API-specific DSL into your handler.
Define API routes using Sinatra-like syntax
any '/…' do |event|
# Handle 'ANY /…' route key events
end
delete '/…' do |event|
# Handle 'DELETE /…' route key events
end
get '/…' do |event|
# Handle 'GET /…' route key events
end
head '/…' do |event|
# Handle 'HEAD /…' route key events
end
options '/…' do |event|
# Handle 'OPTIONS /…' route key events
end
patch '/…' do |event|
# Handle 'PATCH /…' route key events
end
post '/…' do |event|
# Handle 'POST /…' route key events
end
put '/…' do |event|
# Handle 'PUT /…' route key events
endHelper methods are also made available to help produce a response for API Gateway:
Set a default header for ALL responses:
header 'content-type' => 'application/json; charset=utf-8'
header 'x-custom-header' => 'fizz'Produce an API Gateway-style response object:
respond 200, { ok: true }.to_json, 'x-extra-header' => 'buzz'
# {
# "statusCode" => 200,
# "body" => '{"ok":true}',
# "headers" => { "x-extra-header" => "buzz" }
# }Route an event to one of the declared routes:
handler :lambda_handler do |event|
route event
rescue Yake::Errors::UndeclaredRoute => err
respond 404, { message: err.message }.to_json
rescue => err
respond 500, { message: err.message }.to_json
endFinally, yake does not depend on any other gems, using the Ruby stdlib only. This helps keep your Lambda packages slim & speedy.
As of ~> 0.5, yake comes with a support module for common transformations.
Enable the helpers by requiring the support submodule:
require 'yake/support'Object helpers:
MyObject.new.some_method
# => NoMethodError
MyObject.new.try(:some_method)
# => nil
10.try(:some_method) { |x| x ** 2 }
# => 100Hash helpers:
{ a: { b: 'c', d: 'e' }, f: 'g' }.deep_keys
# => [:a, :b, :d, :f]
left = { a: 'b', c: { d: %w[e] } }
right = { a: 'a', c: { d: %w[d] } }
left.deep_merge(right)
# => { :a => "a", :c => { :d => ["e", "d"] } }
{ a: { b: 'c', d: 'e' }, f: 'g' }.deep_transform_keys(&:to_s)
# => { "a" => { "b" => "c", "d" => "e" }, "f" => "g" }
hash = { a: { b: 'c', d: 'e' }, f: 'g' }
hash.deep_transform_keys!(&:to_s)
# => { "a" => { "b" => "c", "d" => "e" }, "f" => "g" }
{ f: 'g', a: { d: 'e', b: 'c' } }.deep_sort
# => { a: { b: 'c', d: 'e' }, f: 'g' }
{ fizz: 'buzz' }.encode64
# => "eyJmaXp6IjoiYnV6eiJ9\n"
{ fizz: 'buzz', jazz: 'fuzz' }.except(:buzz)
# => { :fizz => 'buzz' }
{ fizz: 'buzz' }.strict_encode64
# => "eyJmaXp6IjoiYnV6eiJ9"
{ fizz: { buzz: %w[jazz fuzz] } }.stringify_names
# => { "fizz" => { "buzz" => ["jazz", "fuzz"] } }
{ 'fizz' => { 'buzz' => %w[jazz fuzz] } }.symbolize_names
# => { :fizz => { :buzz => ["jazz", "fuzz"] } }
{ fizz: 'buzz' }.to_form
# => "fizz=buzz"
{ f: 'g', a: { d: 'e', b: 'c' } }.to_json_sorted
# => '{"a":{"b":"c","d":"e"},"f":"g"}'
{ f: 'g', a: { d: 'e', b: 'c' } }.to_struct
# => #<OpenStruct f="g", a={:d=>"e", :b=>"c"}>
{ f: 'g', a: { d: 'e', b: 'c' } }.to_deep_struct
# => #<OpenStruct f="g", a=#<OpenStruct d="e", b="c">>
{ a: { b: 'c', d: 'e' }, f: 'g' }.to_dynamodb
# => { :a => { :M => { :b => { :S => "c" }, :d => { :S => "e" } } }, :f => { :S => "g" } }
{ a: { M: { b: { S: 'c' }, d: { S: 'e' } } }, f: { S: 'g' } }.to_h_from_dynamodb
# => { :a => { :b => "c", :d => "e" }, :f => "g" }Integer helpers:
7.weeks
# => 4_233_600
7.days
# => 604_800
7.hours
# => 25_200
7.minutes
# => 420
1234567890.utc
# => 2009-02-13 23:31:30 UTCString helpers:
host = 'https://example.com/'
path = '/path/to/resource'
host / path
# => "https://example.com/path/to/resource"
'snake_case_string'.camel_case
# => "SnakeCaseString"
"Zml6eg==\n".decode64
# => "fizz"
'fizz'.encode64
# => "Zml6eg==\n"
'fizz'.md5sum
# => "b6bfa6c318811be022d4f73070597660"
'fizz'.sha1sum
# => "c25f5985f2ab63baeb2408a2d7dbc79d8f29d02f"
'CamelCaseString'.snake_case
# => "camel_case_string"
'Zml6eg=='.strict_decode64
# => "fizz"
'fizz'.strict_encode64
# => "Zml6eg=="
'{"fizz":"buzz"}'.to_h_from_json
# => { "fizz" => "buzz" }
'fizz=buzz'.to_h_from_form
# => { "fizz" => "buzz" }
'2009-02-13T23:31:30Z'.utc
# => 2009-02-13 23:31:30 UTCSymbol helpers
:snake_case_symbol.camel_case
# => :SnakeCaseSymbol
:CamelCaseSymbol.snake_case
# => :camel_case_symbolUTC Time helpers
UTC.at 1234567890
# => 2009-02-13 23:31:30 UTC
UTC.now
# => 2022-02-26 13:57:07.860539 UTCAs of v1.0, yake comes with a helper for writing Lambdas that integrate with Datadog's datadog-lambda gem.
As of ~> 0.8, yake uses the v2 Datadog Lambda gem.
Creating a Lambda handler that wraps the Datadog tooling is easy:
require 'aws-sdk-someservice'
require 'yake/datadog'
# Configure Datadog to use AWS tracing
Datadog::Lambda.configure_apm { |c| c.tracing.instrument :aws }
datadog :handler do |event|
# …
endAfter writing your Lambda handler code you can deploy it to AWS using any number of tools. I recommend the following tools:
- Terraform — my personal favorite Infrastructure-as-Code tool
- AWS SAM — a great alternative with less configuration than Terraform
- Serverless — Supposedly the most popular option, though I have not used it
After checking out the repo, run bundle to install dependencies. Then, run rake spec to run the tests.
Bug reports and pull requests are welcome on GitHub at amancevice/yake.
The gem is available as open source under the terms of the MIT License.