airfoil 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 147d3ae419196b330440e2a2c821668627eee5df6a7e9f4659fe2d399c944cf7
-  data.tar.gz: 5ff9c18c639369e9ee451d6ce7d922ecf23cd174a687524eea518fb031221069
+  metadata.gz: 19253bd2e6d9a47232400ac4ee4d7a1fe7953c462af51d419ce6d6fbc941dc50
+  data.tar.gz: '08854bb418dbf76f5254d4132ffaf9f9ba496e7c2398b214e51b55658321c504'
 SHA512:
-  metadata.gz: 86246b400bb9a6b42a956f76062af1392e93514e7492f28f5a29d169f5307dac3fb9ac2dddf56467066a160ee9fb309b0468005454e1f6c179c014e8862618f9
-  data.tar.gz: 4f71ed71afdaef2b7d720140301e67af1eb6376319d5937eee8d1d3e000e4a0e9990961c46b94d8dc74e4343fd6fec66b1c8ef6b4595e0470870d45e3f825231
+  metadata.gz: '084ee1915eca4bfe74e7743d439b5f8fd8db205fed067073a5ad320be13b7164c91a2008b9ec72c394b9cff2189ea1df1835f876a3d11f0a1254f8f72544e1a2'
+  data.tar.gz: 3f03cfdfd2baf6554d344cd2f79dbb6a24c9b71eef66178643f74c3d3edd32369fe85382d9c01f2afb93345fdaf917f9f5b99f182b6fd5f2f027e901de61f5be

data/README.md

@@ -1,4 +1,5 @@
 # Airfoil
+
 _Enough structure to get our Lambda handlers in the air._
 
 Airfoil is curated middleware stack that abstracts away common infrastructure
@@ -14,11 +15,11 @@ gem 'airfoil'
 
 And then execute:
 
-    $ bundle install
+    bundle install
 
 Or install it yourself as:
 
-    $ gem install airfoil
+    gem install airfoil
 
 ## Usage
 
@@ -54,10 +55,38 @@ 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
 
+## Additional Middleware
+
+There are additional middleware available as separate gems that provide specific functionality. They must be explicitly added to your middleware stack in `create_stack`.
+
+### Sentry
+
+Add the `airfoil-sentry` gem to your Gemfile.This provides three middlewares:
+
+- `SentryCatcher` - catch exceptions and report them to Sentry, including context:
+
+```ruby
+b.use Airfoil::Middleware::SentryCatcher
+```
+
+- `SentryMonitoring` - instrument your function code for Sentry's performance monitoring
+
+```ruby
+b.use Airfoil::Middleware::SentryMonitoring
+```
+
+### ActiveRecord
+
+Add the `airfoil-activerecord` gem to your Gemfile. This provides a single middleware:
+
+- `DatabaseConnection` - Check a connection in/out and enable the query cache per handler
+
+```ruby
+b.use Airfoil::Middleware::DatabaseConnection
+```
+
 ## 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.

data/lib/airfoil/railtie.rb

@@ -1,33 +1,8 @@
 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

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

data/lib/airfoil.rb

@@ -3,38 +3,35 @@
 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
+    def create_stack(logger)
       # 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
+        puts "Received SIGTERM, shutting down gracefully..."
       end
 
+      logger ||= defined?(::Rails) ? Rails.logger : Logger.new($stdout, level: (ENV["LOG_LEVEL"] || :info).to_sym)
+
       ::Middleware::Builder.new { |b|
-        b.use Middleware::LoggerTagging, Rails.logger
+        if defined?(::Rails)
+          b.use Middleware::LoggerTagging, logger
+        end
         b.use Middleware::SetRequestId
-        b.use Middleware::Datadog
-        b.use Middleware::SentryCatcher, Rails.logger
-        b.use Middleware::SentryMonitoring
-        b.use Middleware::LogEvent, Rails.logger
+        # This is causing infinite recursion for some reason
+        # b.use Middleware::LogEvent, logger
         yield b
-      }.inject_logger(Rails.logger)
+      }.inject_logger(logger)
     end
   end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: airfoil
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Highwing Engineering
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-10 00:00:00.000000000 Z
+date: 2025-06-09 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
@@ -44,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +52,6 @@ dependencies:
     - - ">="
       - !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
@@ -134,15 +106,10 @@ files:
 - 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:

data/lib/airfoil/middleware/database.rb

@@ -1,17 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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/sentry_catcher.rb

@@ -1,40 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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/step_function.rb

@@ -1,37 +0,0 @@
-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