levo_rails_middleware 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d6f38f672ca75adc4ccb2104c649e20f91866d6965cedc582c21ba5d1388221c
+  data.tar.gz: f0a9fbd1c9dd64ef5a6a11122861cb6ebce9070206f6247bdca3bc2894fb3ff8
+SHA512:
+  metadata.gz: 04ac860aae7b6d04f95123988d855d5af0067dbff89e9d29da58010dd3b894d2e8607d0779d553e6a29bdc758a472aed5b9e1f0a66d768b671ffb53e6bcbb658
+  data.tar.gz: 0cbab4426082bc1eb894472667e184f46274fc58014efad51d737f58278fea9f84cfb92e451f7e678a09c2d9871a99b7b2a1a9979eae245bc6fcc587c70b4477

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Levo Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+
+# Levo Rails Traffic Middleware
+
+[![Gem Version](https://badge.fury.io/rb/levo-rails-traffic-middleware.svg)](https://badge.fury.io/rb/levo-rails-traffic-middleware)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A lightweight, high-performance middleware for mirroring your Rails application API traffic to the Levo.ai platform for API security analysis.
+
+## Overview
+
+The Levo Rails Traffic Middleware captures HTTP requests and responses from your Rails application and securely sends them to the Levo.ai platform. This enables Levo.ai to provide API security analysis, identify vulnerabilities, and help protect your applications without requiring code changes or impacting performance.
+
+Key features:
+- **Zero-impact traffic mirroring**: Asynchronously sends data without affecting your application's response time
+- **Configurable sampling rate**: Control how much traffic is mirrored
+- **Sensitive data filtering**: Automatically filter confidential information
+- **Path exclusion**: Skip static assets and health check endpoints
+- **Size limits**: Prevent excessive data transmission for large payloads
+- **Production-ready**: Built for high-throughput environments
+
+## Requirements
+
+- Ruby 2.6 or later
+- Rails 5.0 or later
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'levo_rails_middleware', git: 'https://github.com/levoai/levo-rails-traffic-middleware.git'
+```
+
+Then execute:
+
+```bash
+$ bundle update
+```
+
+## Quick Start
+
+After installing the gem, you need to:
+
+1. Configure the middleware
+2. Add it to your Rails application
+
+### Configuration
+
+Create an initializer file at `config/initializers/levo_middleware.rb`:
+
+```ruby
+require 'levo_rails_middleware'
+
+LevoRailsMiddleware.configure do |config|
+    # Required: URL for the Levo.ai traffic collector
+    config.remote_url = ENV['LEVO_SATELLITE_URL']
+      
+    # Optional configuration with defaults shown
+    config.sampling_rate = 1.0       # 100% of traffic
+    config.exclude_paths = ['/assets/', '/packs/', '/health']
+    config.filter_params = ['password', 'token', 'api_key', 'secret']
+    config.size_threshold_kb = 1024  # Skip bodies larger than 1MB     config.timeout_seconds = 3
+    config.enabled = true
+  end
+  
+  # Add the middleware to the Rails stack
+  LevoRailsmiddleware.instrument(Rails.application.config)
+```
+
+### Adding the Middleware
+
+In your `config/application.rb` file, add:
+
+```ruby
+module YourApp
+  class Application < Rails::Application
+    # ... other configurations ...
+    
+    # Add the Levo.ai traffic mirroring middleware
+    require 'levo_rails_middleware'
+    LevoRailsmiddleware.instrument(config)
+  end
+end
+```
+
+## Heroku Deployment
+
+For Heroku applications, you'll need to set the environment variable for the Levo middleware URL:
+
+```bash
+heroku config:set LEVO_SATELLITE_URL='https://collector.levo.ai (Replace with your own Satellite url'
+heroku config:set LEVOAI_ORG_ID='your-org-id'
+heroku config:set LEVO_ENV='your-environment-name, like Production or Staging'
+
+```
+
+## Configuration Options
+
+| Option | Description | Default |
+| ------ | ----------- | ------- |
+| `remote_url` | The URL to send mirrored traffic to | `ENV['LEVO_SATELLITE_URL']` |
+| `sampling_rate` | Percentage of requests to mirror (0.0 to 1.0) | `1.0` (100%) |
+| `exclude_paths` | Array of path prefixes to exclude from mirroring | `['/assets/', '/packs/', '/health']` |
+| `filter_params` | Array of parameter names to filter (sensitive data) | `['password', 'token', 'api_key', 'secret']` |
+| `size_threshold_kb` | Maximum size (KB) for request/response bodies | `1024` (1MB) |
+| `timeout_seconds` | Timeout for sending data to Levo.ai | `3` |
+| `enabled` | Toggle to enable/disable the middleware | `true` |
+
+## Advanced Usage
+
+### Conditional Enabling
+
+You may want to enable the middleware only in certain environments:
+
+```ruby
+# In config/initializers/levo_middleware.rb
+LevoRailsMiddleware.configure do |config|
+  config.remote_url = ENV['LEVO_SATELLITE_URL']
+  config.enabled = Rails.env.production? || Rails.env.staging?
+end
+```
+
+### Custom Parameter Filtering
+
+You can specify additional sensitive parameters to filter:
+
+```ruby
+LevoRailsMiddleware.configure do |config|
+  config.filter_params = ['password', 'token', 'api_key', 'secret', 'ssn', 'credit_card']
+end
+```
+
+### Traffic Sampling
+
+For high-traffic applications, you can reduce the sampling rate:
+
+```ruby
+LevoRailsMiddleware.configure do |config|
+  # Mirror only 10% of traffic
+  config.sampling_rate = 0.1
+end
+```
+
+## Troubleshooting
+
+### Verifying Installation
+
+To verify the middleware is properly installed, check your logs for entries containing `LEVO_MIRROR` when your application receives traffic.
+
+### Common Issues
+
+**No data appearing in Levo.ai dashboard**
+
+1. Verify the `LEVO_SATELLITE_URL` is correct
+2. Check your application logs for any errors containing `LEVO_MIRROR`
+3. Ensure the middleware is enabled and the sampling rate is > 0
+4. Confirm your network allows outbound connections to the Levo.ai service
+
+**Performance Impact**
+
+The middleware is designed to have minimal impact on your application's performance. If you notice any impact:
+
+1. Lower the sampling rate to reduce the number of mirrored requests
+2. Increase the `exclude_paths` list to skip more endpoints
+3. Reduce the `size_threshold_kb` to skip large payloads
+
+## Support
+
+For questions or issues, contact Levo.ai support at support@levo.ai or visit [help.levo.ai](https://help.levo.ai).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/levo_rails_middleware/configuration.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module LevoRailsmiddleware
+  class Configuration
+    attr_accessor :remote_url, :sampling_rate, :exclude_paths, :filter_params
+    attr_accessor :size_threshold_kb, :timeout_seconds, :enabled
+    attr_accessor :organization_id, :environment_name, :service_name, :host_name
+    attr_accessor :max_retries
+    
+    def initialize
+      @remote_url = ENV['LEVO_SATELLITE_URL'] || 'https://collector.levo.ai'
+      @sampling_rate = 1.0  # 100% by default
+      @exclude_paths = ['/assets/', '/packs/', '/health']
+      @filter_params = ['password', 'token', 'api_key', 'secret']
+      @size_threshold_kb = 1024  # Skip bodies larger than 1MB
+      @timeout_seconds = 3
+      @enabled = true
+      
+      # Levo Satellite specific configuration
+      @organization_id = ENV['LEVOAI_ORG_ID']
+      @environment_name = ENV['LEVO_ENV']
+      @service_name = ENV['LEVO_SERVICE_NAME'] || 'rails-application'
+      @host_name = get_hostname
+      @max_retries = 3
+    end
+    
+    private
+    
+    def get_hostname
+      # Try to get the hostname, fallback to 'unknown-host'
+      begin
+        Socket.gethostname
+      rescue
+        'unknown-host'
+      end
+    end
+  end
+end

data/lib/levo_rails_middleware/entry.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require 'json'
+
+module LevoRailsmiddleware
+  class Entry
+    attr_reader :timestamp, :duration_ms, :request, :response
+    
+    def initialize(start_time, duration_ms, env, status, headers, body)
+      @timestamp = start_time
+      @duration_ms = duration_ms
+      
+      # Create Rack request object
+      rack_request = Rack::Request.new(env)
+      
+      # Extract request data
+      @request = {
+        method: rack_request.request_method,
+        path: rack_request.path,
+        query_string: rack_request.query_string,
+        headers: extract_headers(env),
+        body: extract_body(rack_request.body),
+        remote_ip: rack_request.ip,
+        request_id: env['HTTP_X_REQUEST_ID'] || env['action_dispatch.request_id']
+      }
+      
+      # Extract response data
+      response_body = extract_response_body(body)
+      
+      @response = {
+        status: status,
+        headers: headers_to_hash(headers),
+        body: response_body,
+        size: response_body.bytesize
+      }
+    end
+    
+    def to_json
+      {
+        timestamp: @timestamp.iso8601,
+        duration_ms: @duration_ms,
+        request: @request,
+        response: @response,
+        environment: Rails.env
+      }.to_json
+    end
+    
+    private
+    
+    def extract_headers(env)
+      headers = {}
+      env.each do |key, value|
+        if key.start_with?('HTTP_')
+          header_name = key[5..-1].gsub('_', '-').downcase
+          headers[header_name] = value
+        end
+      end
+      headers
+    end
+    
+    def extract_body(body)
+      return "".dup unless body  # Return unfrozen empty string
+
+      body.rewind
+      content = body.read.to_s.dup  # Force string conversion and unfreeze
+      body.rewind
+      
+      # Check size threshold
+      if content.bytesize > LevoRailsmiddleware.configuration.size_threshold_kb * 1024
+        "[CONTENT TOO LARGE]"
+      else
+        filter_sensitive_data(content)
+      end
+    end
+
+    def extract_response_body(body)
+      # Start with unfrozen empty string
+      content = "".dup
+
+      # Safely collect response body parts
+      if body.respond_to?(:each)
+        body.each do |part|
+          # Create a duplicate of the string to avoid frozen string issues
+          content << part.to_s.dup
+        end
+      else
+        # Handle case where body might be a string or other object
+        content = body.to_s.dup
+      end
+
+      if content.bytesize > LevoRailsmiddleware.configuration.size_threshold_kb * 1024
+        "[CONTENT TOO LARGE]"
+      else
+        filter_sensitive_data(content)
+      end
+    end
+    
+    def headers_to_hash(headers)
+      hash = {}
+      headers.each do |key, value|
+        hash[key.to_s] = value
+      end
+      hash
+    end
+
+    def filter_sensitive_data(content)
+      # Start with fresh unfrozen copy
+      filtered = content.to_s.dup
+      LevoRailsmiddleware.configuration.filter_params.each do |param|
+        # Simple regex to find and replace sensitive data
+        filtered.gsub!(/["']?#{param}["']?\s*[=:]\s*["']?[^"' &,\}]+["']?/, "#{param}=[FILTERED]")
+      end
+      filtered
+    end
+  end
+end

data/lib/levo_rails_middleware/middleware.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module LevoRailsmiddleware
+    class Middleware
+      def initialize(app)
+        @app = app
+        @sender = Sender.new(LevoRailsmiddleware.configuration.remote_url)
+      rescue => e
+        LevoRailsmiddleware.log_exception("initializing middleware", e)
+        @initialization_failed = true
+      end
+  
+      def call(env)
+        # Skip processing if initialization failed or middleware is disabled
+        return @app.call(env) if @initialization_failed || !LevoRailsmiddleware.configuration.enabled
+        
+        # Skip excluded paths
+        path = env['PATH_INFO'] || ""
+        return @app.call(env) if should_skip?(path)
+        
+        # Skip based on sampling rate
+        return @app.call(env) if rand > LevoRailsmiddleware.configuration.sampling_rate
+        
+        start_time = Time.now
+        
+        # Preserve the original request body
+        request_body = env['rack.input'].read
+        env['rack.input'].rewind
+        
+        # Process the request through the app
+        status, headers, body = @app.call(env)
+        end_time = Time.now
+        
+        # Calculate the request duration
+        duration_ms = ((end_time.to_f - start_time.to_f) * 1000).round
+        
+        # Save the original input stream
+        saved_input = env['rack.input']
+        env['rack.input'] = StringIO.new(request_body)
+        
+        # Create the request/response entry and send it
+        begin
+          entry = Entry.new(start_time, duration_ms, env, status, headers, body)
+          @sender.send_async(entry)
+        rescue => e
+          LevoRailsmiddleware.log_exception("processing request", e)
+        ensure
+          # Restore the original input stream
+          env['rack.input'] = saved_input
+        end
+        
+        [status, headers, body]
+      rescue => e
+        LevoRailsmiddleware.log_exception("middleware execution", e)
+        @app.call(env)  # Ensure we still call the app even if our middleware fails
+      end
+      
+      private
+      
+      def should_skip?(path)
+        LevoRailsmiddleware.configuration.exclude_paths.any? do |excluded|
+          path.start_with?(excluded)
+        end
+      end
+    end
+  end

data/lib/levo_rails_middleware/sender.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+require 'net/http'
+require 'uri'
+require 'json'
+require 'securerandom'
+
+module LevoRailsmiddleware
+  class Sender
+    API_ENDPOINT = "/1.0/ebpf/traces"
+
+    def initialize(remote_url)
+      @remote_url = remote_url
+      @uri = URI.parse(remote_url) if remote_url
+      Rails.logger.info "LEVO_MIRROR: Initialized with URL #{@remote_url}" if defined?(Rails)
+    end
+
+    def send_async(entry)
+      return if @remote_url.nil?
+
+      # Use a separate thread to avoid blocking the request
+      Thread.new do
+        begin
+          send_data(entry)
+        rescue => e
+          LevoRailsmiddleware.log_exception("sending data", e)
+        ensure
+          # Ensure database connection is released
+          ActiveRecord::Base.connection_pool.release_connection if defined?(ActiveRecord)
+        end
+      end
+    end
+
+    private
+
+    def send_data(entry)
+      # Convert entry to Levo Satellite format
+      trace = convert_to_satellite_format(entry)
+      json_data = JSON.generate([trace])
+
+      Rails.logger.debug "LEVO_MIRROR: JSON payload preview (first 200 chars): #{json_data[0..200]}..." if defined?(Rails)
+
+      # Create HTTP client
+      http = Net::HTTP.new(@uri.host, @uri.port)
+
+      # Configure HTTPS if needed
+      if @uri.scheme == 'https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      # Set timeouts
+      timeout = LevoRailsmiddleware.configuration.timeout_seconds
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+
+      # Construct API path correctly
+      endpoint_path = API_ENDPOINT
+      base_path = @uri.path.to_s
+
+      # Ensure the path is properly formed
+      if base_path.empty?
+        full_path = endpoint_path
+      else
+        # Handle trailing slashes correctly
+        if base_path.end_with?('/') && endpoint_path.start_with?('/')
+          full_path = base_path + endpoint_path[1..-1]
+        elsif !base_path.end_with?('/') && !endpoint_path.start_with?('/')
+          full_path = "#{base_path}/#{endpoint_path}"
+        else
+          full_path = base_path + endpoint_path
+        end
+      end
+
+      # Create request with the properly formed path
+      request = Net::HTTP::Post.new(full_path)
+      request.content_type = 'application/json'
+
+      # Add Levo organization ID header
+      if LevoRailsmiddleware.configuration.organization_id
+        request['x-levo-organization-id'] = LevoRailsmiddleware.configuration.organization_id
+      end
+
+      # Add request ID header if available
+      request_id = entry.request[:request_id]
+      request['X-Request-ID'] = request_id if request_id
+
+      # Set the request body
+      request.body = json_data
+
+      # Send request with retry logic
+      response = nil
+      success = false
+
+      # Retry logic
+      max_retries = LevoRailsmiddleware.configuration.max_retries
+
+      for attempt in 0...max_retries
+        if attempt > 0
+          # Exponential backoff with jitter
+          backoff_ms = (2 ** attempt) * 100 + rand(1000)
+          sleep(backoff_ms / 1000.0)
+          Rails.logger.info "LEVO_MIRROR: Retry attempt #{attempt+1} for sending trace data" if defined?(Rails)
+        end
+
+        begin
+          response = http.request(request)
+
+          # Check status code
+          if response.code.to_i >= 200 && response.code.to_i < 300
+            success = true
+            break
+          else
+            Rails.logger.error "LEVO_MIRROR: Failed to send data. Status: #{response.code}" if defined?(Rails)
+          end
+        rescue => e
+          Rails.logger.error "LEVO_MIRROR: Error during HTTP request: #{e.message}" if defined?(Rails)
+        end
+      end
+
+      if success
+        Rails.logger.info "LEVO_MIRROR: Successfully sent trace data, status: #{response.code}" if defined?(Rails)
+      else
+        Rails.logger.error "LEVO_MIRROR: Failed to send trace after #{max_retries} attempts" if defined?(Rails)
+      end
+    end
+
+    def convert_to_satellite_format(entry)
+      # Generate trace and span IDs similar to the C++ implementation
+      trace_id = SecureRandom.uuid
+      span_id = SecureRandom.uuid
+
+      # Calculate duration in nanoseconds
+      duration_ns = entry.duration_ms * 1_000_000
+
+      # Get current time in nanoseconds
+      request_time_ns = (Time.now.to_f * 1_000_000_000).to_i
+
+      # Extract request method and path
+      method = entry.request[:method]
+      path = entry.request[:path]
+
+      # Convert headers to the expected format
+      request_headers = {}
+      entry.request[:headers].each do |name, value|
+        request_headers[name.downcase] = value
+      end
+
+      # Add special headers that the backend expects
+      request_headers[":path"] = path
+      request_headers[":method"] = method
+      request_headers[":authority"] = request_headers["host"] if request_headers["host"]
+
+      response_headers = {}
+      entry.response[:headers].each do |name, value|
+        response_headers[name.downcase] = value
+      end
+
+      # Add special response headers
+      response_headers[":status"] = entry.response[:status].to_s
+
+      # Build the trace structure
+      {
+        "http_scheme" => (request_headers['x-forwarded-proto'] || 'http'),
+        "request" => {
+          "headers" => request_headers,
+          "body" => Base64.strict_encode64(entry.request[:body].to_s),
+          "truncated" => false
+        },
+        "response" => {
+          "headers" => response_headers,
+          "body" => Base64.strict_encode64(entry.response[:body].to_s),
+          "truncated" => false,
+          "status_code" => entry.response[:status]
+        },
+        "resource" => {
+          "service_name" => LevoRailsmiddleware.configuration.service_name,
+          "host_name" => LevoRailsmiddleware.configuration.host_name,
+          "telemetry_sdk_language" => "ruby",
+          "telemetry_sdk_name" => "levo_rails_middleware",
+          "telemetry_sdk_version" => LevoRailsmiddleware::VERSION,
+          "levo_env" => LevoRailsmiddleware.configuration.environment_name
+        },
+        "duration_ns" => duration_ns,
+        "request_time_ns" => request_time_ns,
+        "trace_id" => trace_id,
+        "span_id" => span_id,
+        "span_kind" => "SERVER",
+        "path" => path,
+        "method" => method,
+        "client_ip" => entry.request[:remote_ip]
+      }
+    end
+  end
+end

data/lib/levo_rails_middleware/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LevoRailsmiddleware
+    VERSION = "0.1.1"
+  end

data/lib/levo_rails_middleware.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'levo_rails_middleware/version'
+require 'levo_rails_middleware/configuration'
+require 'levo_rails_middleware/middleware'
+require 'levo_rails_middleware/entry'
+require 'levo_rails_middleware/sender'
+
+module LevoRailsmiddleware
+  class << self
+    attr_writer :configuration
+
+    # Access the configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configure the middleware
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    # Add middleware to Rails application
+    def instrument(app_config)
+      # Use the class constant instead of a string
+      app_config.middleware.use LevoRailsmiddleware::Middleware  # Changed from insert_before with string
+    end
+
+    # Log exceptions
+    def log_exception(context, exception)
+      Rails.logger.error "LEVO_middleware: Exception while #{context}: #{exception.message} (#{exception.class.name})"
+      exception.backtrace&.each do |line|
+        Rails.logger.error "LEVO_middleware:   #{line}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: levo_rails_middleware
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Levo.ai Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !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: 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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A Rails middleware for Levo.ai customers that captures HTTP requests
+  and responses and sends them to Levo.ai for API security analysis
+email:
+- support@levo.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/levo_rails_middleware.rb
+- lib/levo_rails_middleware/configuration.rb
+- lib/levo_rails_middleware/entry.rb
+- lib/levo_rails_middleware/middleware.rb
+- lib/levo_rails_middleware/sender.rb
+- lib/levo_rails_middleware/version.rb
+homepage: https://github.com/levoai/levo-rails-middleware
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+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: API traffic middlewareing middleware for Rails applications
+test_files: []