aws_lambda_ric_jets 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 419c518036274ceb445e3b66e67a55331959f60c622481f420fcce305fee35fe
+  data.tar.gz: e99bad60222c55e767fc363adcce81d4693c327cd3f6b742367e4bb08e872755
+SHA512:
+  metadata.gz: 69ee4fe58a0f9ab23a7777e83c2ffc035a034a808e6ad54a44164075e8b32ba70a94ec171aed199d11e0a402d968e2dfa15c3ff017b80212b4ed7d90b6663495
+  data.tar.gz: 1bb742a4bf392d32e0180487d770e3a0ec8f1769ad10641d850c85213d73db3c1467c1756ebc2bdee23b76e93a1fe6e47140697dcac9d5d4eca337ebd7c53223

data/Gemfile

@@ -0,0 +1,10 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in aws_lambda_ric.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,229 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/ TERMS
+AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+     
+
+
+      "License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+      
+
+     
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+      
+
+      "Legal Entity" shall mean the
+union of the acting entity and all other entities that control, are controlled
+by, or are under common control with that entity. For the purposes of this
+definition, "control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or otherwise, or (ii)
+ownership of fifty percent (50%) or more of the outstanding shares, or (iii)
+beneficial ownership of such entity.
+
+      
+
+      "You" (or "Your") shall mean
+an individual or Legal Entity exercising permissions granted by this License.
+
+  
+
+
+      "Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation source, and
+configuration files.
+
+      
+
+      "Object" form shall mean any form resulting
+from mechanical transformation or translation of a Source form, including but not
+limited to compiled object code, generated documentation, and conversions to
+other media types.
+
+      
+
+      "Work" shall mean the work of authorship,
+whether in Source or Object form, made available under the License, as indicated
+by a copyright notice that is included in or attached to the work (an example is
+provided in the Appendix below).
+
+      
+
+      "Derivative Works" shall mean any
+work, whether in Source or Object form, that is based on (or derived from) the
+Work and for which the editorial revisions, annotations, elaborations, or other
+modifications represent, as a whole, an original work of authorship. For the
+purposes of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of, the Work
+and Derivative Works thereof.
+
+      
+
+      "Contribution" shall mean any work
+of authorship, including the original version of the Work and any modifications
+or additions to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner or by an
+individual or Legal Entity authorized to submit on behalf of the copyright owner.
+For the purposes of this definition, "submitted" means any form of electronic,
+verbal, or written communication sent to the Licensor or its representatives,
+including but not limited to communication on electronic mailing lists, source
+code control systems, and issue tracking systems that are managed by, or on
+behalf of, the Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise designated in
+writing by the copyright owner as "Not a Contribution."
+
+      
+
+     
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of
+whom a Contribution has been received by Licensor and subsequently incorporated
+within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and
+conditions of this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license
+to reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or Object
+form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+section) patent license to make, have made, use, offer to sell, sell, import, and
+otherwise transfer the Work, where such license applies only to those patent
+claims licensable by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s) with the Work to
+which such Contribution(s) was submitted. If You institute patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Work or a Contribution incorporated within the Work constitutes
+direct or contributory patent infringement, then any patent licenses granted to
+You under this License for that Work shall terminate as of the date such
+litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute
+copies of the Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You meet the following
+conditions:
+
+      (a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+      (b) You must cause any
+modified files to carry prominent notices stating that You changed the files;
+and
+
+      (c) You must retain, in the Source form of any Derivative Works that
+You distribute, all copyright, patent, trademark, and attribution notices from
+the Source form of the Work, excluding those notices that do not pertain to any
+part of the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text
+file as part of its distribution, then any Derivative Works that You distribute
+must include a readable copy of the attribution notices contained within such
+NOTICE file, excluding those notices that do not pertain to any part of the
+Derivative Works, in at least one of the following places: within a NOTICE text
+file distributed as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or, within a display
+generated by the Derivative Works, if and wherever such third-party notices
+normally appear. The contents of the NOTICE file are for informational purposes
+only and do not modify the License. You may add Your own attribution notices
+within Derivative Works that You distribute, alongside or as an addendum to the
+NOTICE text from the Work, provided that such additional attribution notices
+cannot be construed as modifying the License.
+
+      You may add Your own
+copyright statement to Your modifications and may provide additional or different
+license terms and conditions for use, reproduction, or distribution of Your
+modifications, or for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with the conditions
+stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly
+state otherwise, any Contribution intentionally submitted for inclusion in the
+Work by You to the Licensor shall be under the terms and conditions of this
+License, without any additional terms or conditions. Notwithstanding the above,
+nothing herein shall supersede or modify the terms of any separate license
+agreement you may have executed with Licensor regarding such Contributions.
+
+  
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless
+required by applicable law or agreed to in writing, Licensor provides the Work
+(and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including,
+without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible
+for determining the appropriateness of using or redistributing the Work and
+assume any risks associated with Your exercise of permissions under this
+License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise, unless required
+by applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any character
+arising as a result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages or
+losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer, and charge a fee
+for, acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole responsibility,
+not on behalf of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability incurred by, or
+claims asserted against, such Contributor by reason of your accepting any such
+warranty or additional liability. END OF TERMS AND CONDITIONS
+
+APPENDIX: How to
+apply the Apache License to your work.
+
+To apply the Apache License to your work,
+attach the following boilerplate notice, with the fields enclosed by brackets
+"[]" replaced with your own identifying information. (Don't include the
+brackets!) The text should be enclosed in the appropriate comment syntax for the
+file format. We also recommend that a file or class name and description of
+purpose be included on the same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright [yyyy] Edgar
+Hernandez
+
+Licensed under the Apache License, Version 2.0 (the "License");
+
+you
+may not use this file except in compliance with the License.
+
+You may obtain a
+copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless
+required by applicable law or agreed to in writing, software
+
+distributed under
+the License is distributed on an "AS IS" BASIS,
+
+WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, either express or implied.
+
+See the License for the specific
+language governing permissions and
+
+limitations under the License.

data/NOTICE

@@ -0,0 +1 @@
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

data/README.md

@@ -0,0 +1,164 @@
+## AWS Lambda Ruby Runtime Interface Client
+
+For the reason for this fork, see: [README.jets.md](/README.jets.md)
+
+We have open-sourced a set of software packages, Runtime Interface Clients (RIC), that implement the Lambda
+ [Runtime API](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html), allowing you to seamlessly extend your preferred
+  base images to be Lambda compatible.
+The Lambda Runtime Interface Client is a lightweight interface that allows your runtime to receive requests from and send requests to the Lambda service.
+
+The Lambda Ruby Runtime Interface Client is vended through [rubygems](https://rubygems.org/gems/aws_lambda_ric).
+You can include this package in your preferred base image to make that base image Lambda compatible.
+
+## Requirements
+The Ruby Runtime Interface Client package currently supports Ruby versions:
+ - 2.5.x up to and including 2.7.x
+
+## Usage
+
+### Creating a Docker Image for Lambda with the Runtime Interface Client
+First step is to choose the base image to be used. The supported Linux OS distributions are:
+
+ - Amazon Linux 2
+ - Alpine
+ - CentOS
+ - Debian
+ - Ubuntu
+
+In order to install the Runtime Interface Client, either add this line to your application's Gemfile:
+
+```ruby
+gem 'aws_lambda_ric'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it manually as:
+
+    $ gem install aws_lambda_ric
+
+
+Next step would be to copy your Lambda function code into the image's working directory.
+```dockerfile
+# Copy function code
+RUN mkdir -p ${FUNCTION_DIR}
+COPY app.rb ${FUNCTION_DIR}
+
+WORKDIR ${FUNCTION_DIR}
+```
+
+The next step would be to set the `ENTRYPOINT` property of the Docker image to invoke the Runtime Interface Client and then set the `CMD` argument to specify the desired handler.
+
+Example Dockerfile:
+```dockerfile
+FROM amazonlinux:latest
+
+# Define custom function directory
+ARG FUNCTION_DIR="/function"
+
+# Install ruby
+RUN amazon-linux-extras install -y ruby2.6
+
+# Install bundler
+RUN gem install bundler
+
+# Install the Runtime Interface Client
+RUN gem install aws_lambda_ric
+
+# Copy function code
+RUN mkdir -p ${FUNCTION_DIR}
+COPY app.rb ${FUNCTION_DIR}
+
+WORKDIR ${FUNCTION_DIR}
+
+ENTRYPOINT ["/usr/local/bin/aws_lambda_ric"]
+CMD ["app.App::Handler.process"]
+```
+
+Example Ruby handler `app.rb`:
+```ruby
+module App
+  class Handler
+    def self.process(event:, context:)
+      "Hello World!"
+    end
+  end
+end
+```
+
+### Local Testing
+
+To make it easy to locally test Lambda functions packaged as container images we open-sourced a lightweight web-server, Lambda Runtime Interface Emulator (RIE), which allows your function packaged as a container image to accept HTTP requests. You can install the [AWS Lambda Runtime Interface Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator) on your local machine to test your function. Then when you run the image function, you set the entrypoint to be the emulator.
+
+*To install the emulator and test your Lambda function*
+
+1) From your project directory, run the following command to download the RIE from GitHub and install it on your local machine.
+
+```shell script
+mkdir -p ~/.aws-lambda-rie && \
+    curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
+    chmod +x ~/.aws-lambda-rie/aws-lambda-rie
+```
+2) Run your Lambda image function using the docker run command.
+
+```shell script
+docker run -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
+    --entrypoint /aws-lambda/aws-lambda-rie \
+    myfunction:latest \
+        /usr/local/bin/aws_lambda_ric app.App::Handler.process
+```
+
+This runs the image as a container and starts up an endpoint locally at `http://localhost:9000/2015-03-31/functions/function/invocations`.
+
+3) Post an event to the following endpoint using a curl command:
+
+```shell script
+curl -XPOST "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
+```
+
+This command invokes the function running in the container image and returns a response.
+
+*Alternately, you can also include RIE as a part of your base image. See the AWS documentation on how to [Build RIE into your base image](https://docs.aws.amazon.com/lambda/latest/dg/images-test.html#images-test-alternative).*
+
+## Development
+
+### Building the package
+Clone this repository and run:
+
+```shell script
+make init
+make build
+```
+
+### Running tests
+
+Make sure the project is built:
+```shell script
+make init build
+```
+Then,
+* to run unit tests: `make test-unit`
+* to run integration tests: `make test-integ`
+* to run smoke tests: `make test-smoke`
+
+### Troubleshooting
+While running integration tests, you might encounter the Docker Hub rate limit error with the following body:
+```
+You have reached your pull rate limit. You may increase the limit by authenticating and upgrading: https://www.docker.com/increase-rate-limits
+```
+To fix the above issue, consider authenticating to a Docker Hub account by setting the Docker Hub credentials as below CodeBuild environment variables.
+```shell script
+DOCKERHUB_USERNAME=<dockerhub username>
+DOCKERHUB_PASSWORD=<dockerhub password>
+```
+Recommended way is to set the Docker Hub credentials in CodeBuild job by retrieving them from AWS Secrets Manager.
+
+## Security
+
+If you discover a potential security issue in this project we ask that you notify AWS/Amazon Security via our [vulnerability reporting page](http://aws.amazon.com/security/vulnerability-reporting/). Please do **not** create a public github issue.
+
+## License
+
+This project is licensed under the Apache-2.0 License.

data/aws_lambda_ric.gemspec

@@ -0,0 +1,45 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "./lib/aws_lambda_ric_jets/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "aws_lambda_ric_jets"
+  spec.version = AwsLambdaRicJets::VERSION
+  spec.authors = ["Tung Nguyen"]
+  # Original name and authors below for credit.
+  # They are not maintaining this fork.
+  # spec.name                  = 'aws_lambda_ric_jets'
+  # spec.version               = AwsLambdaRicJets::VERSION
+  # spec.authors               = ['AWS Lambda']
+
+  spec.summary = "AWS Lambda Runtime Interface Client for Ruby"
+  spec.description = "The AWS Lambda Ruby Runtime Interface Client implements the Lambda programming model for Ruby."
+  spec.homepage = "https://github.com/aws/aws-lambda-ruby-runtime-interface-client"
+
+  spec.license = "Apache-2.0"
+  spec.required_ruby_version = ">= 2.5"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = %w[
+    LICENSE
+    README.md
+    Gemfile
+    NOTICE
+    aws_lambda_ric.gemspec
+    bin/aws_lambda_ric
+  ] + Dir["lib/**/*"]
+
+  spec.bindir = "bin"
+  # all application-style files are expected to be found in bindir
+  spec.executables = "aws_lambda_ric"
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", ">= 2.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "activesupport", "~> 6.0.1"
+end

data/bin/aws_lambda_ric

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require_relative '../lib/aws_lambda_ric/bootstrap'
+
+Bootstrap.start

data/lib/aws_lambda_ric/aws_lambda_marshaller.rb

@@ -0,0 +1,37 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+require 'stringio'
+
+module AwsLambda
+  class Marshaller
+    class << self
+      # By default, JSON-parses the raw request body. This can be overwritten
+      # by users who know what they are doing.
+      def marshall_request(raw_request)
+        content_type = raw_request['Content-Type']
+        if content_type == 'application/json'
+          JSON.parse(raw_request.body)
+        else
+          raw_request.body # return it unaltered
+        end
+      end
+
+      # By default, just runs #to_json on the method's response value.
+      # This can be overwritten by users who know what they are doing.
+      # The response is an array of response, content-type.
+      # If returned without a content-type, it is assumed to be application/json
+      # Finally, StringIO/IO is used to signal a response that shouldn't be
+      # formatted as JSON, and should get a different content-type header.
+      def marshall_response(method_response)
+        case method_response
+        when StringIO, IO
+          [method_response, 'application/unknown']
+        else
+          method_response.to_json # application/json is assumed
+        end
+      end
+    end
+  end
+end

data/lib/aws_lambda_ric/bootstrap.rb

@@ -0,0 +1,45 @@
+require_relative '../aws_lambda_ric'
+
+# Bootstrap runtime
+module Bootstrap
+
+  def self.start
+    bootstrap_telemetry_log_sink
+    bootstrap_handler
+  end
+
+  def self.fetch_runtime_server
+    ENV.fetch(AwsLambdaRuntimeInterfaceClient::LambdaRunner::ENV_VAR_RUNTIME_API)
+  rescue KeyError
+    puts 'Failed to get runtime server address from AWS_LAMBDA_RUNTIME_API env variable'
+    exit(-2)
+  end
+
+  def self.bootstrap_telemetry_log_sink(path_to_fd='/proc/self/fd/')
+    fd = ENV.fetch(AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper::ENV_VAR_TELEMETRY_LOG_FD)
+    ENV.delete(AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper::ENV_VAR_TELEMETRY_LOG_FD)
+    AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper.new(fd, path_to_fd)
+  rescue KeyError
+    puts 'Skipped bootstraping TelemetryLog'
+  end
+
+  def self.bootstrap_handler
+    if ARGV.empty?
+      puts 'No handler specified, exiting Runtime Interface Client.'
+      exit
+    end
+    app_root = Dir.pwd
+    handler = ARGV[0]
+    lambda_runner = AwsLambdaRuntimeInterfaceClient::LambdaRunner.new(fetch_runtime_server, get_user_agent)
+    puts "Executing '#{handler}' in function directory '#{app_root}'"
+    lambda_runner.run(app_root, handler)
+  end
+
+  def self.get_user_agent
+    ruby_version = RUBY_VERSION.to_s
+    version = AwsLambdaRuntimeInterfaceClient::VERSION
+ 
+    "aws-lambda-ruby/#{ruby_version}-#{version}"
+  end
+
+end

data/lib/aws_lambda_ric/lambda_context.rb

@@ -0,0 +1,29 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+class LambdaContext
+  attr_reader :aws_request_id, :invoked_function_arn, :log_group_name,
+              :log_stream_name, :function_name, :memory_limit_in_mb, :function_version,
+              :identity, :client_context, :deadline_ms
+
+  def initialize(request)
+    @clock_diff = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond) - Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    @deadline_ms = request['Lambda-Runtime-Deadline-Ms'].to_i
+    @aws_request_id = request['Lambda-Runtime-Aws-Request-Id']
+    @invoked_function_arn = request['Lambda-Runtime-Invoked-Function-Arn']
+    @log_group_name = ENV['AWS_LAMBDA_LOG_GROUP_NAME']
+    @log_stream_name = ENV['AWS_LAMBDA_LOG_STREAM_NAME']
+    @function_name = ENV['AWS_LAMBDA_FUNCTION_NAME']
+    @memory_limit_in_mb = ENV['AWS_LAMBDA_FUNCTION_MEMORY_SIZE']
+    @function_version = ENV['AWS_LAMBDA_FUNCTION_VERSION']
+    @identity = JSON.parse(request['Lambda-Runtime-Cognito-Identity']) unless request['Lambda-Runtime-Cognito-Identity'].to_s.empty?
+    @client_context = JSON.parse(request['Lambda-Runtime-Client-Context']) unless request['Lambda-Runtime-Client-Context'].to_s.empty?
+  end
+
+  def get_remaining_time_in_millis
+    now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) + @clock_diff
+    remaining = @deadline_ms - now
+    remaining.positive? ? remaining : 0
+  end
+end

data/lib/aws_lambda_ric/lambda_errors.rb

@@ -0,0 +1,85 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+module LambdaErrors
+
+  class LambdaErrors::InvocationError < StandardError;
+  end
+
+  class LambdaError < StandardError
+    def initialize(original_error, classification = 'Function')
+      @error_class = original_error.class.to_s
+      @error_type = "#{classification}<#{original_error.class}>"
+      @error_message = original_error.message
+      @stack_trace = _sanitize_stacktrace(original_error.backtrace_locations)
+      super(original_error)
+    end
+
+    def runtime_error_type
+      if _allowed_error?
+        @error_type
+      else
+        'Function<UserException>'
+      end
+    end
+
+    def to_lambda_response
+      {
+          :errorMessage => @error_message,
+          :errorType => @error_type,
+          :stackTrace => @stack_trace
+      }
+    end
+
+    private
+
+    def _sanitize_stacktrace(stacktrace)
+      ret = []
+      safe_trace = true
+      if stacktrace
+        stacktrace.first(100).each do |line|
+          if safe_trace
+            if line.to_s.match(%r{^lib})
+              safe_trace = false
+            else
+              ret << line
+            end
+          end # else skip
+        end
+      end
+      ret
+    end
+
+    def _allowed_error?
+      # _aws_sdk_pattern? || _standard_error?
+      _standard_error?
+    end
+
+    # Currently unused, may be activated later.
+    def _aws_sdk_pattern?
+      @error_class.match(/Aws(::\w+)*::Errors/)
+    end
+
+    def _standard_error?
+      %w[ArgumentError NoMethodError Exception StandardError NameError LoadError SystemExit SystemStackError].include?(@error_class)
+    end
+  end
+
+  class LambdaHandlerError < LambdaError
+  end
+
+  class LambdaHandlerCriticalException < LambdaError
+  end
+
+  class LambdaRuntimeError < LambdaError
+    def initialize(original_error)
+      super(original_error, 'Runtime')
+    end
+  end
+
+  class LambdaRuntimeInitError < LambdaError
+    def initialize(original_error)
+      super(original_error, 'Init')
+    end
+  end
+end

data/lib/aws_lambda_ric/lambda_handler.rb

@@ -0,0 +1,43 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+require_relative 'aws_lambda_marshaller'
+
+# frozen_string_literal: true
+class LambdaHandler
+  attr_reader :handler_file_name, :handler_method_name
+
+  def initialize(env_handler:)
+    handler_split = env_handler.split('.')
+    if handler_split.size == 2
+      @handler_file_name, @handler_method_name = handler_split
+    elsif handler_split.size == 3
+      @handler_file_name, @handler_class, @handler_method_name = handler_split
+    else
+      raise ArgumentError.new("Invalid handler #{handler_split}, must be of form FILENAME.METHOD or FILENAME.CLASS.METHOD where FILENAME corresponds with an existing Ruby source file FILENAME.rb, CLASS is an optional module/class namespace and METHOD is a callable method. If using CLASS, METHOD must be a class-level method.")
+    end
+  end
+
+  def call_handler(request:, context:)
+    opts = {
+        event: request,
+        context: context
+    }
+    if @handler_class
+      response = Kernel.const_get(@handler_class).send(@handler_method_name, **opts)
+    else
+      response = __send__(@handler_method_name, **opts)
+    end
+    # serialization can be a part of user code
+    AwsLambda::Marshaller.marshall_response(response)
+  rescue NoMethodError => e
+    # This is a special case of standard error that we want to hard-fail for
+    raise LambdaErrors::LambdaHandlerCriticalException.new(e)
+  rescue NameError => e
+    # This is a special case error that we want to wrap
+    raise LambdaErrors::LambdaHandlerCriticalException.new(e)
+  rescue StandardError => e
+    raise LambdaErrors::LambdaHandlerError.new(e)
+  rescue Exception => e
+    raise LambdaErrors::LambdaHandlerCriticalException.new(e)
+  end
+end

data/lib/aws_lambda_ric/lambda_log_formatter.rb

@@ -0,0 +1,14 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+require 'logger'
+
+class LambdaLogFormatter < Logger::Formatter
+  FORMAT = '%<sev>s, [%<datetime>s#%<process>d] %<severity>5s %<request_id>s -- %<progname>s: %<msg>s'
+
+  def call(severity, time, progname, msg)
+    (FORMAT % {sev: severity[0..0], datetime: format_datetime(time), process: $$, severity: severity,
+               request_id: $_global_aws_request_id, progname: progname, msg: msg2str(msg)}).encode!('UTF-8')
+  end
+end

data/lib/aws_lambda_ric/lambda_logger.rb

@@ -0,0 +1,10 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+class LambdaLogger
+  class << self
+    def log_error(exception:, message: nil)
+      puts message if message
+      puts JSON.pretty_unparse(exception.to_lambda_response)
+    end
+  end
+end

data/lib/aws_lambda_ric/lambda_server.rb

@@ -0,0 +1,89 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require_relative 'lambda_errors'
+
+class LambdaServer
+  LAMBDA_DEFAULT_SERVER_ADDRESS = '127.0.0.1:9001'
+  LAMBDA_RUNTIME_API_VERSION = '2018-06-01'
+
+  MAX_HEADER_SIZE_BYTES = 1024 * 1024
+  LONG_TIMEOUT_MS = 1_000_000
+
+  def initialize(server_address, user_agent)
+    server_address ||= LAMBDA_DEFAULT_SERVER_ADDRESS
+    @server_address = "http://#{server_address}/#{LAMBDA_RUNTIME_API_VERSION}"
+    @user_agent = user_agent
+  end
+
+  def next_invocation
+    next_invocation_uri = URI(@server_address + '/runtime/invocation/next')
+    begin
+      http = Net::HTTP.new(next_invocation_uri.host, next_invocation_uri.port)
+      http.read_timeout = LONG_TIMEOUT_MS
+      resp = http.start do |connection|
+        connection.get(next_invocation_uri.path, { 'User-Agent' => @user_agent })
+      end
+      if resp.is_a?(Net::HTTPSuccess)
+        request_id = resp['Lambda-Runtime-Aws-Request-Id']
+        [request_id, resp]
+      else
+        raise LambdaErrors::InvocationError.new(
+            "Received #{resp.code} when waiting for next invocation."
+        )
+      end
+    rescue LambdaErrors::InvocationError => e
+      raise e
+    rescue StandardError => e
+      raise LambdaErrors::InvocationError.new(e)
+    end
+  end
+
+  def send_response(request_id:, response_object:, content_type: 'application/json')
+    response_uri = URI(@server_address + "/runtime/invocation/#{request_id}/response")
+    begin
+      # unpack IO at this point
+      if content_type == 'application/unknown'
+        response_object = response_object.read
+      end
+      Net::HTTP.post(
+          response_uri,
+          response_object,
+          { 'Content-Type' => content_type, 'User-Agent' => @user_agent }
+      )
+    rescue StandardError => e
+      raise LambdaErrors::LambdaRuntimeError.new(e)
+    end
+  end
+
+  def send_error_response(request_id:, error_object:, error:, xray_cause:)
+    response_uri = URI(@server_address + "/runtime/invocation/#{request_id}/error")
+    begin
+      headers = { 'Lambda-Runtime-Function-Error-Type' => error.runtime_error_type, 'User-Agent' => @user_agent }
+      headers['Lambda-Runtime-Function-XRay-Error-Cause'] = xray_cause if xray_cause.bytesize < MAX_HEADER_SIZE_BYTES
+      Net::HTTP.post(
+          response_uri,
+          error_object.to_json,
+          headers
+      )
+    rescue StandardError => e
+      raise LambdaErrors::LambdaRuntimeError.new(e)
+    end
+  end
+
+  def send_init_error(error_object:, error:)
+    uri = URI("#{@server_address}/runtime/init/error")
+    begin
+      Net::HTTP.post(
+          uri,
+          error_object.to_json,
+          { 'Lambda-Runtime-Function-Error-Type' => error.runtime_error_type, 'User-Agent' => @user_agent }
+      )
+    rescue StandardError => e
+      raise LambdaErrors::LambdaRuntimeInitError.new(e)
+    end
+  end
+end

data/lib/aws_lambda_ric/logger_patch.rb

@@ -0,0 +1,21 @@
+# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+module LoggerPatch
+  def initialize(logdev, shift_age = 0, shift_size = 1048576, level: 'debug',
+                 progname: nil, formatter: nil, datetime_format: nil,
+                 binmode: false, shift_period_suffix: '%Y%m%d')
+    #  use unpatched constructor if logdev is a filename or an IO Object other than $stdout or $stderr
+    if logdev && logdev != $stdout && logdev != $stderr
+      super(logdev, shift_age, shift_size, level: level, progname: progname,
+                      formatter: formatter, datetime_format: datetime_format,
+                      binmode: binmode, shift_period_suffix: shift_period_suffix)
+    else
+      self.level = level
+      self.progname = progname
+      @default_formatter = LambdaLogFormatter.new
+      self.datetime_format = datetime_format
+      self.formatter = formatter
+      @logdev = AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper.telemetry_log_sink
+    end
+  end
+end

data/lib/aws_lambda_ric/telemetry_log_sink.rb

@@ -0,0 +1,43 @@
+# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+require 'logger'
+
+class TelemetryLogSink < Logger::LogDevice
+
+  # TelemetryLogSink implements the logging contract between runtimes and the platform. It implements a simple
+  # framing protocol so message boundaries can be determined. Each frame can be visualized as follows:
+  #
+  # +----------------------+------------------------+-----------------------+
+  # | Frame Type - 4 bytes | Length (len) - 4 bytes | Message - \'len\' bytes |
+  # +----------------------+------------------------+-----------------------+
+  #
+  # The first 4 bytes indicate the type of the frame - log frames have a type defined as the hex value 0xa55a0001. The
+  # second 4 bytes should indicate the message\'s length. The next \'len\' bytes contain the message. The byte order is
+  # big-endian.
+
+  def initialize(file:)
+    @file = file
+  end
+
+  FRAME_BYTES = [0xa55a0001].pack('L>')
+
+  def write(msg)
+    if @file.nil? || @file.closed?
+      $stdout.write(msg)
+    else
+      @file.write(FRAME_BYTES)
+      @file.write([msg.bytesize].pack('L>'))
+      @file.write(msg)
+    end
+  end
+
+  def reopen(log = nil)
+    # do nothing
+  end
+
+  def close
+    # do nothing
+  end
+end

data/lib/aws_lambda_ric/version.rb

@@ -0,0 +1,7 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+module AwsLambdaRuntimeInterfaceClient
+  VERSION = '2.0.0'
+end

data/lib/aws_lambda_ric/xray_cause.rb

@@ -0,0 +1,42 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+require_relative 'lambda_errors'
+
+class XRayCause
+  MAX_DEPTH = 15
+
+  def initialize(lambda_error)
+    @cause = {
+      working_directory: Dir.pwd,
+      paths: Gem.paths.path,
+      exceptions: lambda_error ? normalize(err: lambda_error) : lambda_error
+    }
+  end
+
+  def as_json
+    @as_json ||= begin
+      JSON.dump(@cause)
+    end
+  end
+
+  private
+
+  def normalize(err:)
+    exception = {
+      message: err[:errorMessage],
+      type: err[:errorType]
+    }
+
+    backtrace = err[:stackTrace]
+    if backtrace
+      exception[:stack] = backtrace.first(MAX_DEPTH).collect do |t|
+        {
+          path: t.path,
+          line: t.lineno,
+          label: t.label
+        }
+      end
+    end
+    [exception]
+  end
+end

data/lib/aws_lambda_ric.rb

@@ -0,0 +1,179 @@
+# Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+# frozen_string_literal: true
+
+require_relative 'aws_lambda_ric/lambda_errors'
+require_relative 'aws_lambda_ric/lambda_server'
+require_relative 'aws_lambda_ric/lambda_handler'
+require_relative 'aws_lambda_ric/lambda_context'
+require_relative 'aws_lambda_ric/lambda_logger'
+require_relative 'aws_lambda_ric/lambda_log_formatter'
+require_relative 'aws_lambda_ric/logger_patch'
+require_relative 'aws_lambda_ric/telemetry_log_sink'
+require_relative 'aws_lambda_ric/aws_lambda_marshaller'
+require_relative 'aws_lambda_ric/xray_cause'
+require_relative 'aws_lambda_ric/version'
+require 'logger'
+
+$stdout.sync = true # Ensures that logs are flushed promptly.
+
+module AwsLambdaRuntimeInterfaceClient
+
+  class Error < StandardError; end
+
+  # Loads the user code and runs it upon invocation
+  class LambdaRunner
+
+    ENV_VAR_RUNTIME_API = 'AWS_LAMBDA_RUNTIME_API'
+
+    def initialize(runtime_server_addr, user_agent)
+      @lambda_server = LambdaServer.new(runtime_server_addr, user_agent)
+      @runtime_loop_active = true # if false, we will exit the program
+      @exit_code = 0
+    end
+
+    def run(app_root, handler)
+
+      $LOAD_PATH.unshift(app_root) unless $LOAD_PATH.include?(app_root)
+
+      begin
+        @lambda_handler = LambdaHandler.new(env_handler: handler)
+        require @lambda_handler.handler_file_name
+        start_runtime_loop
+      rescue Exception => e # which includes LoadError or any exception within static user code
+        @runtime_loop_active = false
+        @exit_code = -4
+        send_init_error_to_server(e)
+      ensure
+        TelemetryLoggingHelper.close
+      end
+
+      exit(@exit_code)
+    end
+
+    private
+
+    def start_runtime_loop
+      while @runtime_loop_active
+        lambda_invocation_request = wait_for_invocation
+        run_user_code(lambda_invocation_request)
+      end
+    end
+
+    def wait_for_invocation
+      request_id, raw_request = @lambda_server.next_invocation
+      $_global_aws_request_id = request_id
+      if (trace_id = raw_request['Lambda-Runtime-Trace-Id'])
+        ENV['_X_AMZN_TRACE_ID'] = trace_id
+      end
+      request = AwsLambda::Marshaller.marshall_request(raw_request)
+
+      LambdaInvocationRequest.new(request_id, raw_request, request, trace_id)
+    rescue LambdaErrors::InvocationError => e
+      @runtime_loop_active = false # ends the loop
+      raise e # ends the process
+    end
+
+    def run_user_code(lambda_invocation_request)
+      context = LambdaContext.new(lambda_invocation_request.raw_request) # pass in opts
+
+      # start of user code
+      handler_response, content_type = @lambda_handler.call_handler(
+        request: lambda_invocation_request.request,
+        context: context
+      )
+      # end of user code
+
+      @lambda_server.send_response(
+        request_id: lambda_invocation_request.request_id,
+        response_object: handler_response,
+        content_type: content_type
+      )
+
+    rescue LambdaErrors::LambdaHandlerError => e
+      LambdaLogger.log_error(exception: e, message: 'Error raised from handler method')
+      send_error_response(lambda_invocation_request, e)
+    rescue LambdaErrors::LambdaHandlerCriticalException => e
+      LambdaLogger.log_error(exception: e, message: 'Critical exception from handler')
+      send_error_response(lambda_invocation_request, e, -1, false)
+    rescue LambdaErrors::LambdaRuntimeError => e
+      send_error_response(lambda_invocation_request, e, -2, false)
+    end
+
+    def send_init_error_to_server(err)
+      ex = LambdaErrors::LambdaRuntimeInitError.new(err)
+      LambdaLogger.log_error(exception: ex, message: "Init error when loading handler #{@env_handler}")
+      @lambda_server.send_init_error(error_object: ex.to_lambda_response, error: ex)
+    end
+
+    def send_error_response(lambda_invocation, err, exit_code = nil, runtime_loop_active = true)
+      error_object = err.to_lambda_response
+      @lambda_server.send_error_response(
+        request_id: lambda_invocation.request_id,
+        error_object: error_object,
+        error: err,
+        xray_cause: XRayCause.new(error_object).as_json
+      )
+
+      @exit_code = exit_code unless exit_code.nil?
+      @runtime_loop_active = runtime_loop_active
+    end
+  end
+
+  # Helper class to for mutating std logger with TelemetryLog
+  class TelemetryLoggingHelper
+
+    ENV_VAR_TELEMETRY_LOG_FD = '_LAMBDA_TELEMETRY_LOG_FD'
+
+    class << self
+      attr_accessor :telemetry_log_fd_file, :telemetry_log_sink
+
+      def close
+        telemetry_log_fd_file&.close
+      end
+    end
+
+    def initialize(telemetry_log_fd, path_to_fd='/proc/self/fd/')
+      fd = "#{path_to_fd}#{telemetry_log_fd}"
+      AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper.telemetry_log_fd_file = File.open(fd, 'wb')
+      AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper.telemetry_log_fd_file.sync = true
+
+      AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper.telemetry_log_sink = TelemetryLogSink.new(file: AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper.telemetry_log_fd_file)
+
+      mutate_std_logger
+      mutate_kernel_puts
+    rescue Errno::ENOENT
+      # If File.open() fails, then the mutation won't happen and the default behaviour (print to stdout) will prevail
+    end
+
+    private
+
+    def mutate_std_logger
+      Logger.class_eval do
+        prepend LoggerPatch
+      end
+    end
+
+    def mutate_kernel_puts
+      Kernel.module_eval do
+        def puts(*arg)
+          msg = arg.flatten.collect { |a| a.to_s.encode('UTF-8') }.join("\n")
+          AwsLambdaRuntimeInterfaceClient::TelemetryLoggingHelper.telemetry_log_sink.write(msg)
+        end
+      end
+    end
+  end
+
+  # Represents a single Lambda Invocation Request
+  class LambdaInvocationRequest
+
+    attr_accessor :request_id, :raw_request, :request, :trace_id
+
+    def initialize(request_id, raw_request, request, trace_id)
+      @request_id = request_id
+      @raw_request = raw_request
+      @request = request
+      @trace_id = trace_id
+    end
+  end
+end

data/lib/aws_lambda_ric_jets/version.rb

@@ -0,0 +1,4 @@
+# Separate version for the fork to keep it clear
+module AwsLambdaRicJets
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: aws_lambda_ric_jets
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tung Nguyen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.1
+description: The AWS Lambda Ruby Runtime Interface Client implements the Lambda programming
+  model for Ruby.
+email: 
+executables:
+- aws_lambda_ric
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- NOTICE
+- README.md
+- aws_lambda_ric.gemspec
+- bin/aws_lambda_ric
+- lib/aws_lambda_ric.rb
+- lib/aws_lambda_ric/aws_lambda_marshaller.rb
+- lib/aws_lambda_ric/bootstrap.rb
+- lib/aws_lambda_ric/lambda_context.rb
+- lib/aws_lambda_ric/lambda_errors.rb
+- lib/aws_lambda_ric/lambda_handler.rb
+- lib/aws_lambda_ric/lambda_log_formatter.rb
+- lib/aws_lambda_ric/lambda_logger.rb
+- lib/aws_lambda_ric/lambda_server.rb
+- lib/aws_lambda_ric/logger_patch.rb
+- lib/aws_lambda_ric/telemetry_log_sink.rb
+- lib/aws_lambda_ric/version.rb
+- lib/aws_lambda_ric/xray_cause.rb
+- lib/aws_lambda_ric_jets/version.rb
+homepage: https://github.com/aws/aws-lambda-ruby-runtime-interface-client
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key: 
+specification_version: 4
+summary: AWS Lambda Runtime Interface Client for Ruby
+test_files: []