yake 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7f5484562df0ab45af1304729d8f5c6edc2a66082ba4bcd4ca718bcfdba1d96
-  data.tar.gz: c63cb492e9a31e9cd29a06c93493bb28f7f1823eae6eb8f06a4d889b204048bc
+  metadata.gz: 5a82e9c31a2af64f0db3fe44f694da9328239bb47c1c4a9fb4734ff66172d96e
+  data.tar.gz: a5175886ce9623095fa52a94a7993d9fefc8f53604f7188b7cbb42cf3c3be6c2
 SHA512:
-  metadata.gz: fec877aefb902caa3b64562c255ac9d8f33dbbe878de88af3bfc985dacac7f4e7f2ad8c02dbc873987defb1c64f85695d2d6da035596ad5e3ee1c168a5303f27
-  data.tar.gz: 5641f87b78f5fce7c1eec4cfd8c422afa56247ad27ab936587840563998feb98f1198e291c2b9c508f30414cf282a6f988ed0d79db18c639b21e6560266deba6
+  metadata.gz: 7107fffe0cc8edde7184c0063456b24047daff692fd2a610d551f67a1815a6f6b59fcad4a3e10ba215cb25a53c278f8b73701eb5e676febba473cdce2d5a7e1f
+  data.tar.gz: f4242662c6b17d314d3ff2f536d0d4016860c18276d30e48b0d39fb07891a282d713a390760a5f862c3d3637263d5a111afe79e23c7b72cd54831487fc9322ac

data/README.md

@@ -1,5 +1,10 @@
 # λake
 
+![gem](https://img.shields.io/gem/v/yake?color=crimson&logo=rubygems&logoColor=eee&style=flat-square)
+[![rspec](https://img.shields.io/github/workflow/status/amancevice/yake/RSpec?logo=github&style=flat-square)](https://github.com/amancevice/yake/actions)
+[![coverage](https://img.shields.io/codeclimate/coverage/amancevice/yake?logo=code-climate&style=flat-square)](https://codeclimate.com/github/amancevice/yake/test_coverage)
+[![maintainability](https://img.shields.io/codeclimate/maintainability/amancevice/yake?logo=code-climate&style=flat-square)](https://codeclimate.com/github/amancevice/yake/maintainability)
+
 Write your AWS Lambda function handlers using a Rake-like declarative syntax:
 
 ```ruby
@@ -21,7 +26,7 @@ require "yake/api"
 
 header "content-type" => "application/json"
 
-get "/fizz" do |handler|
+get "/fizz" do
   respond 200, { ok: true }.to_json
 end
 
@@ -54,19 +59,17 @@ Or install it yourself as:
 gem install yake
 ```
 
-## Why Use It?
+## Why Is It Called "yake"?
 
-So why use `yake` for your Lambda functions?
+"λ" + Rake, but "λ" is hard to type and I think "y" looks like a funny little upside-down-and-backwards Lambda symbol.
 
-#### Zero Dependencies
+## Why Use It?
 
-`yake` does not depend on any other gems, using the Ruby stdlib only. This helps keep your Lambda packages slim & speedy.
+So why use `yake` for your Lambda functions?
 
 #### Event Logging
 
-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 logs the input event and the returned value prefixed with the ID of the request.
-
-Example log lines:
+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
@@ -77,14 +80,25 @@ 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
 ```
 
-This makes gathering logs lines for a particular execution in CloudWatch much easier.
+Logging the request ID in this way makes gathering logs lines for a particular execution in CloudWatch much easier.
 
-This feature can be disabled by adding a declaration in your handler:
+This feature can be disabled by adding a declaration in your handler file:
 
 ```ruby
 logging :off
 ```
 
+Include `Yake::Logging` on a class to access this logger:
+
+```ruby
+class Fizz
+  include Yake::Logger
+end
+
+Fizz.new.logger == Yake.logger
+# => true
+```
+
 #### API Routes
 
 A 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.
@@ -94,41 +108,33 @@ Requiring the `yake/api` module will add the API-specific DSL into your handler.
 Define API routes using Sinatra-like syntax
 
 ```ruby
-# Declare 'DELETE /…' route key
 delete "/…" do |event|
-  # …
+  # Handle 'DELETE /…' route key events
 end
 
-# Declare 'GET /…' route key
 get "/…" do |event|
-  # …
+  # Handle 'GET /…' route key events
 end
 
-# Declare 'HEAD /…' route key
 head "/…" do |event|
-  # …
+  # Handle 'HEAD /…' route key events
 end
 
-# Declare 'OPTIONS /…' route key
 options "/…" do |event|
-  # …
+  # Handle 'OPTIONS /…' route key events
 end
 
-# Declare 'PATCH /…' route key
 patch "/…" do |event|
-  # …
+  # Handle 'PATCH /…' route key events
 end
 
-# Declare 'POST /…' route key
 post "/…" do |event|
-  # …
+  # Handle 'POST /…' route key events
 end
 
-# Declare 'PUT /…' route key
 put "/…" do |event|
-  # …
+  # Handle 'PUT /…' route key events
 end
-
 ```
 
 Helper methods are also made available to help produce a response for API Gateway:
@@ -137,31 +143,36 @@ Set a default header for ALL responses:
 
 ```ruby
 header "content-type" => "application/json; charset=utf-8"
+header "x-custom-header" => "fizz"
 ```
 
 Produce an API Gateway-style response object:
 
 ```ruby
-respond 200, { ok: true }.to_json, "x-extra-header" => "fizz"
+respond 200, { ok: true }.to_json, "x-extra-header" => "buzz"
 # {
 #   "statusCode" => 200,
 #   "body" => '{"ok":true}',
-#   "headers" => { "x-extra-header" => "fizz" }
+#   "headers" => { "x-extra-header" => "buzz" }
 # }
 ```
 
 Route an event to one of the declared routes:
 
 ```ruby
-begin
+handler :lambda_handler do |event|
   route event
 rescue Yake::UndeclaredRoute => err
   respond 404, { message: err.message }.to_json
 rescue => err
-  respond 500 { message: err.message }.to_json
+  respond 500, { message: err.message }.to_json
 end
 ```
 
+#### Zero Dependencies
+
+Finally, `yake` does not depend on any other gems, using the Ruby stdlib only. This helps keep your Lambda packages slim & speedy.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -175,7 +186,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/amance
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-```
-
-```

data/lib/yake/api.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "base64"
 require "json"
 
 require "yake"

data/lib/yake/dsl.rb

@@ -10,17 +10,17 @@ module Yake
     # Lambda handler task wrapper
     def handler(name, &block)
       define_method(name) do |event:nil, context:nil|
-        Yake.logger.nil? ? yield(event, context) : Yake.logger.wrap(event, context, &block)
+        Yake.wrap(event, context, &block)
       end
     end
 
     ##
     # Turn logging on/off
-    def logging(switch, **options)
+    def logging(switch, logger = nil)
       if switch == :on
-        Yake.logger = Yake::Logger.new
+        Yake.logger = logger
       elsif switch == :off
-        Yake.logger = nil
+        Yake.logger = ::Logger.new(nil)
       else
         raise Errors::UnknownLoggingSetting, switch
       end
@@ -29,4 +29,3 @@ module Yake
 end
 
 extend Yake::DSL
-Yake.logger = Yake::Logger.new

data/lib/yake/logger.rb

@@ -4,33 +4,41 @@ require "json"
 require "logger"
 
 module Yake
-  class Logger < ::Logger
-    def initialize(logdev = $stdout, *)
-      super
-      @progname  = "-"
-      @formatter = LambdaFormatter.new
+  module Logger
+    attr_accessor :logger
+
+    def logger
+      @logger ||= Yake.logger
     end
 
-    def wrap(event = nil, context = nil, &block)
-      @progname = "RequestId: #{ context.aws_request_id }" if context.respond_to?(:aws_request_id)
-      info("EVENT #{ event.to_json }")
-      yield(event, context).tap { |res| info("RETURN #{ res.to_json }") }
-    ensure
-      @progname = "-"
+    class << self
+      def new(logdev = $stdout)
+        ::Logger.new(logdev, progname: "-", formatter: Formatter.new)
+      end
     end
-  end
 
-  class LambdaFormatter < ::Logger::Formatter
-    Format = "%s %s %s\n"
+    class Formatter < ::Logger::Formatter
+      Format = "%s %s %s\n"
 
-    def call(severity, time, progname, msg)
-      Format % [ severity, progname, msg2str(msg).strip ]
+      def call(severity, time, progname, msg)
+        Format % [ severity, progname, msg2str(msg).strip ]
+      end
     end
   end
 
-  module Loggable
+  class << self
     attr_accessor :logger
-  end
 
-  extend Loggable
+    def logger
+      @logger ||= Logger.new
+    end
+
+    def wrap(event = nil, context = nil, &block)
+      logger.progname = "RequestId: #{ context.aws_request_id }" if context.respond_to?(:aws_request_id)
+      logger.info("EVENT #{ event.to_json }")
+      yield(event, context).tap { |res| logger.info("RETURN #{ res.to_json }") }
+    ensure
+      logger.progname = "-"
+    end
+  end
 end

data/lib/yake/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yake
-  VERSION = "0.1.0"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yake
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Alexander Mancevice
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-27 00:00:00.000000000 Z
+date: 2021-05-01 00:00:00.000000000 Z
 dependencies: []
 description:
 email: