airfoil 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cafc414d07d58d199bc9058066119516cf27810402bac47c7c7cb253ebee85a3
+  data.tar.gz: c694dd87b5a2f228b03701580c33c0063751a077c3d23c410e230d6702b8937a
+SHA512:
+  metadata.gz: 685294eccb81796e1b4338ff99cbd849d8997fde13cc2437e0839b8134bfcb9b99ecf630bd462c6fa7aa3a03a102e689ad54b1147849e868c96e5aa74758f3d9
+  data.tar.gz: b0a8f3e5314f1006b8fb5dc85b2955ead9b7f089798e44afab0f96801bc3dfe67d4579669f09f48620d274af09dac919059a8c77323a7b4240571c45ea98d990

data/README.md

@@ -0,0 +1,65 @@
+# Airfoil
+_Enough structure to get our Lambda handlers in the air._
+
+Airfoil is curated middleware stack that abstracts away common infrastructure
+needed for Lambda handler functions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'airfoil'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install airfoil
+
+## Usage
+
+You can instantiate a new handler with an Airfoil stack like so:
+
+```ruby
+require_relative "config/environment"
+
+STACK = Airfoil.create_stack do |b|
+  # Custom middleware and handlers go here
+  b.use Airfoil::Middleware::FunctionName, DbReset, "db-reset"
+  b.use Airfoil::Middleware::FunctionName, UpdateUpcomingRenewals, "update-upcoming-renewals"
+end
+
+def handler(event:, context:)
+  STACK.call({event: event, context: context})
+end
+```
+
+Airfoil also includes a stack of middleware that you can add to or customize to
+suit your specific needs. Your own middleware can inherit from the base class and
+implement their own behavior like so:
+
+```ruby
+class MyResolverMiddleware < Airfoil::Middleware::Base
+  def call(env)
+    ApplicationResolver.handle(env[:event], env[:context])
+  end
+end
+```
+
+Existing middleware include:
+
+- `FunctionName` - dispatch any calls made to a specific Lambda function (by name) to a specified handler class
+- `LogEvent` - log AWS events in a pretty format
+- `SentryCatcher` - catch exceptions and report them to Sentry, including context
+- `SentryMonitoring` - instrument your function code for Sentry's performance monitoring
+- `SetRequestId` - set the `AWS_REQUEST_ID` environment variable for your function code
+
+## 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.
+
+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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).

data/lib/airfoil/cloudwatch_formatter.rb

@@ -0,0 +1,9 @@
+require "logger"
+
+module Airfoil
+  class CloudwatchFormatter < Logger::Formatter
+    def call(severity, datetime, progname, msg)
+      "#{severity} RequestId: #{ENV["AWS_REQUEST_ID"]} #{msg}\n"
+    end
+  end
+end

data/lib/airfoil/logger_patch.rb

@@ -0,0 +1,15 @@
+# The built-in Middleware gem logger truncates the event so instead
+# we have our own logging middleware to print the event and context.
+# Here, we reopen the class and ignoring the partial event to cut down on log chatter.
+class ::Middleware::Logger
+  def way_in_message name, env
+    " %s has been called with: %s" % [name, env[:context].function_name]
+  end
+
+  # Default to omitting middleware logging
+  def write msg
+    if ENV["MIDDLEWARE_LOGGING_ENABLED"] == "true"
+      @write_to.add(::Logger::INFO, msg.slice(0, 255).strip!, @middleware_name)
+    end
+  end
+end

data/lib/airfoil/middleware/base.rb

@@ -0,0 +1,9 @@
+module Airfoil
+  module Middleware
+    class Base
+      def initialize(app)
+        @app = app
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/database.rb

@@ -0,0 +1,17 @@
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class Database < Airfoil::Middleware::Base
+      def call(env)
+        # TODO: This explicitly makes a connection, which we may want to re-evaluate at some point
+        ActiveRecord::Base.connection_pool.with_connection do |conn|
+          conn.enable_query_cache!
+          @app.call(env)
+        ensure
+          conn.disable_query_cache!
+        end
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/datadog.rb

@@ -0,0 +1,23 @@
+require "datadog/lambda"
+require "datadog/tracing"
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class Datadog < Base
+      # See the Airfoil railtie for config loaded at Rails load-time
+      # Note: Rails loads prior to Airfoil because of the inclusion of `require_relative "config/environment"`
+      # in the engine lambda handler
+      def call(env)
+        event, context = env.values_at(:event, :context)
+
+        ::Datadog::Lambda.wrap(event, context) do
+          @app.call(env)
+        rescue => err
+          ::Datadog::Tracing.active_span&.set_error(err)
+          raise err
+        end
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/function_name.rb

@@ -0,0 +1,35 @@
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class FunctionName < Middleware::Base
+      def initialize(app, handler_class, *function_names_to_match)
+        super(app)
+        @handler_class = handler_class
+        @function_names_to_match = function_names_to_match
+      end
+
+      def call(env)
+        context = env[:context]
+
+        if handles? context
+          @handler_class.handle(env[:event], context)
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def handles?(context)
+        @function_names_to_match.include?(canonicalize_function_name(context.function_name))
+      end
+
+      # Strip off the function suffix if present to allow for terraform/terratest to invoke lambdas with unique names that route to the same function
+      # e.g. finalize-submission-testrun89YD36 => finalize-submission
+      def canonicalize_function_name(function_name)
+        function_name.sub(/-testrun[a-zA-Z0-9]*$/, "")
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/log_event.rb

@@ -0,0 +1,71 @@
+require "dry-monads"
+require "active_support"
+require "active_support/core_ext/hash/except"
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class LogEvent < Base
+      include Dry::Monads[:maybe]
+
+      def initialize(app, logger)
+        super(app)
+        @logger = logger
+      end
+
+      def call(env)
+        event = env[:event]
+
+        logged_data = {
+          "identity" => log_identity(event),
+          "event" => log_event(event)
+        }.to_json
+
+        @logger.info(logged_data)
+        result = @app.call(env)
+        # Log the full result instead of the truncated version the middleware outputs
+        @logger.info({result: result}.to_json)
+        result
+      end
+
+      private
+
+      # Clear unwanted properties from our log output
+      def clean_event(event)
+        unwanted_fields = %w[identity]
+        event.except(*unwanted_fields)
+      end
+
+      def log_event(event)
+        return event if event.is_a?(String)
+
+        # Remove the full identity from our event output
+        if event.is_a?(Array)
+          event.map { |e| clean_event(e) }
+        else
+          clean_event(event)
+        end
+      end
+
+      def log_identity(event)
+        identity = case event
+        in [e, *rest]
+          e.dig("identity")
+        in Hash
+          event.dig("identity")
+        else
+          nil
+        end
+
+        Maybe(identity).bind { |i|
+          Some({
+            groups: i.dig("groups"),
+            source_ip: i.dig("sourceIp"),
+            sub: i.dig("sub"),
+            auth_time: i.dig("claims", "auth_time")
+          })
+        }.value_or(nil)
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/logger_tagging.rb

@@ -0,0 +1,19 @@
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class LoggerTagging < Base
+      def initialize(app, logger)
+        super(app)
+        @logger = logger
+      end
+
+      def call(env)
+        context = env[:context]
+        @logger.tagged(ENV["_X_AMZN_TRACE_ID"], context.aws_request_id) do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/sentry_catcher.rb

@@ -0,0 +1,40 @@
+require "sentry-ruby"
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class SentryCatcher < Base
+      def initialize(app, logger)
+        super(app)
+        @logger = logger
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue => err
+        Sentry.with_scope do |scope|
+          context = env[:context]
+          event = env[:event]
+
+          scope.set_extras(
+            function_name: context.function_name,
+            function_version: context.function_version,
+            invoked_function_arn: context.invoked_function_arn,
+            memory_limit_in_mb: context.memory_limit_in_mb,
+            aws_request_id: context.aws_request_id,
+            log_group_name: context.log_group_name,
+            log_stream_name: context.log_stream_name,
+            identity: context.identity,
+            event: event
+          )
+
+          Sentry.capture_exception(err)
+          @logger.error(err)
+          raise err
+        end
+      end
+    end
+
+    class RequestError < StandardError; end
+  end
+end

data/lib/airfoil/middleware/sentry_monitoring.rb

@@ -0,0 +1,42 @@
+require "sentry-ruby"
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class SentryMonitoring < Base
+      def call(env)
+        event, context = env.values_at(:event, :context)
+        sentry_trace_id = get_first_instance(event, "sentry_trace_id")
+        identity = get_first_instance(event, "identity")
+
+        options = {name: context.function_name, op: "handler"}
+        options[:transaction] = Sentry::Transaction.from_sentry_trace(sentry_trace_id, **options) if sentry_trace_id.present?
+
+        Sentry.set_user(username: identity.dig("username"), ip_address: identity.dig("source_ip", 0)) if identity.present?
+        transaction = Sentry.start_transaction(**options)
+        # Add transaction to the global scope so it is accessible throughout the app
+        Sentry.get_current_hub&.configure_scope do |scope|
+          scope.set_span(transaction)
+        end
+
+        result = @app.call(env)
+        transaction.finish if transaction.present?
+
+        result
+      end
+
+      private
+
+      def get_first_instance(event, key)
+        case event
+        in [e, *rest]
+          e.dig(key)
+        in Hash
+          event.dig(key)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/set_request_id.rb

@@ -0,0 +1,13 @@
+require "airfoil/middleware/base"
+
+module Airfoil
+  module Middleware
+    class SetRequestId < Base
+      def call(env)
+        context = env[:context]
+        ENV["AWS_REQUEST_ID"] = context.aws_request_id if context.present?
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/airfoil/middleware/step_function.rb

@@ -0,0 +1,37 @@
+require_relative "function_name"
+
+module Airfoil
+  module Middleware
+    class StepFunction < FunctionName
+      def initialize(app, handler_class, *function_names_to_match, retried_exceptions: [])
+        super(app, handler_class, *function_names_to_match)
+        @retried_exceptions = retried_exceptions.map(&:to_s)
+      end
+
+      def call(env)
+        context = env[:context]
+
+        ignore_exceptions(context) do
+          super
+        end
+      end
+
+      def ignore_exceptions(context)
+        disable_exceptions
+        result = yield
+        enable_exceptions
+
+        result
+      end
+
+      def disable_exceptions
+        @before = Sentry.configuration.excluded_exceptions
+        Sentry.configuration.excluded_exceptions += @retried_exceptions
+      end
+
+      def enable_exceptions
+        Sentry.configuration.excluded_exceptions = @before
+      end
+    end
+  end
+end

data/lib/airfoil/railtie.rb

@@ -0,0 +1,33 @@
+require "airfoil/cloudwatch_formatter"
+require "datadog/lambda"
+
+module Airfoil
+  class Railtie < Rails::Railtie
+    # Format logs for consistent parsing by Cloudwatch
+    config.log_formatter = Airfoil::CloudwatchFormatter.new
+    config.datadog_enabled = ENV.fetch("DATADOG_ENABLED", Rails.env.production?).to_s == "true"
+
+    initializer "airfoil.datadog" do
+      if Rails.configuration.datadog_enabled
+        require "ddtrace/auto_instrument"
+
+        ::Datadog::Lambda.configure_apm do |c|
+          c.env = ENV.fetch("SENTRY_ENVIRONMENT", Rails.env).dasherize
+          # downscasing first ensures we don't attempt to snake case things that don't already have dashes
+          c.service = ENV.fetch("AWS_LAMBDA_FUNCTION_NAME", "brokersuite").downcase.underscore
+
+          # Set trace rate via DD_TRACE_SAMPLE_RATE
+          c.tracing.enabled = true
+          c.tracing.instrument :aws
+          c.tracing.instrument :faraday
+          c.tracing.instrument :rest_client
+          c.tracing.instrument :httpclient
+          c.tracing.instrument :http
+          c.tracing.instrument :rails
+        end
+
+        Rails.logger.debug "=====DATADOG LOADED (RAILTIE)====="
+      end
+    end
+  end
+end

data/lib/airfoil/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Airfoil
+  VERSION = '0.1.2'
+end

data/lib/airfoil.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "middleware"
+
+require_relative "airfoil/version"
+require_relative "airfoil/middleware/database"
+require_relative "airfoil/middleware/datadog"
+require_relative "airfoil/middleware/function_name"
+require_relative "airfoil/middleware/log_event"
+require_relative "airfoil/middleware/logger_tagging"
+require_relative "airfoil/middleware/sentry_catcher"
+require_relative "airfoil/middleware/sentry_monitoring"
+require_relative "airfoil/middleware/set_request_id"
+require_relative "airfoil/middleware/step_function"
+require_relative "airfoil/logger_patch"
+require_relative "airfoil/railtie" if defined?(Rails::Railtie)
+
+module Airfoil
+  class << self
+    def create_stack
+      # ensure that STDOUT streams are synchronous so we don't lose logs
+      $stdout.sync = true
+
+      Signal.trap("TERM") do
+        # We can't use the Rails logger here as the logger is not available in the trap context
+        puts "Received SIGTERM, shutting down gracefully..." # rubocop:disable Rails/Output
+      end
+
+      ::Middleware::Builder.new { |b|
+        b.use Middleware::LoggerTagging, Rails.logger
+        b.use Middleware::SetRequestId
+        b.use Middleware::Datadog
+        b.use Middleware::SentryCatcher, Rails.logger
+        b.use Middleware::SentryMonitoring
+        b.use Middleware::LogEvent, Rails.logger
+        yield b
+      }.inject_logger(Rails.logger)
+    end
+  end
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: airfoil
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Highwing Engineering
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: datadog-lambda
+  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: dry-monads
+  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: ibsciss-middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: railties
+  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: sentry-ruby
+  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: aws_lambda_ric
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- engineering@highwing.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/airfoil.rb
+- lib/airfoil/cloudwatch_formatter.rb
+- lib/airfoil/logger_patch.rb
+- lib/airfoil/middleware/base.rb
+- lib/airfoil/middleware/database.rb
+- lib/airfoil/middleware/datadog.rb
+- lib/airfoil/middleware/function_name.rb
+- lib/airfoil/middleware/log_event.rb
+- lib/airfoil/middleware/logger_tagging.rb
+- lib/airfoil/middleware/sentry_catcher.rb
+- lib/airfoil/middleware/sentry_monitoring.rb
+- lib/airfoil/middleware/set_request_id.rb
+- lib/airfoil/middleware/step_function.rb
+- lib/airfoil/railtie.rb
+- lib/airfoil/version.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.17
+signing_key:
+specification_version: 4
+summary: Enough structure to get our Lambda handlers in the air
+test_files: []