nurse_andrea 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0ab519a0523b2ddcd45d545236cb6b29f9d4ed1013d67cd771597838dc091cab
+  data.tar.gz: eed1931c5dbe44eeb9ee91ea5d2eb3df391681d6972a593d6c8f0faab0f9b733
+SHA512:
+  metadata.gz: 2c01153fec0178129a99b5fad4ce5e680006e40022f35b7f10531f5a7150a5247286239dd598af0129f2eb0af4ecf186e33af823f13f65aec1e6308b8d5b8bb5
+  data.tar.gz: 1e90759917304321798cea006be838067d9c5f0668a8363a0a29e672721fd70d10b169f4459615e869df0bc1d39227dfdb8b1d108180f18755ec788e87137f81

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+## [0.1.2] - 2026-04-05
+
+### Added
+- `NurseAndrea::Configuration#host` — configurable base URL for all SDK endpoints. Defaults to `https://nurseandrea.io`.
+- All ingest, metrics, traces, and handshake URLs are now derived from `host`. Nothing is hardcoded.
+- `token` / `token=` aliases for `api_key` / `api_key=`
+
+### Migration
+Add `c.host = ENV.fetch("NURSE_ANDREA_HOST", "https://nurseandrea.io")` to your initializer.
+
+## [0.1.1] - 2026-04-05
+
+### Changed
+- LogInterceptor now captures OpenTelemetry trace_id and span_id in log metadata when an OTel span is active
+
+## [0.1.0] - 2026-04-03
+
+### Added
+- Initial release
+- Log shipping via background thread (thread-safe queue, configurable batch size and flush interval)
+- Request metrics via Rack middleware (duration, status, normalized path)
+- Log backfill on first connection (configurable hours, JSON and plaintext log formats)
+- Handshake/status endpoint at `/nurse_andrea/status`
+- Rails install generator (`rails generate nurse_andrea:install`)
+- Zero runtime dependencies beyond Ruby stdlib

data/README.md

@@ -0,0 +1,46 @@
+# NurseAndrea Ruby SDK
+
+The official Ruby gem for [NurseAndrea](https://nurseandrea.com) — observability for Rails startups.
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "nurse_andrea"
+```
+
+Then run:
+
+```bash
+bundle install
+rails generate nurse_andrea:install
+```
+
+Set your API key:
+
+```bash
+export NURSE_ANDREA_API_KEY="your_token_from_dashboard"
+```
+
+## What it does
+
+- **Log shipping** — captures all `Rails.logger` calls and ships them to your NurseAndrea dashboard
+- **Request metrics** — measures every HTTP request (duration, status code, path) via Rack middleware
+- **Backfill** — ships the last 24h of your Rails log file on first startup
+- **Health endpoint** — mounts `/nurse_andrea/status` so the dashboard can verify your connection
+
+## Configuration
+
+```ruby
+NurseAndrea.configure do |config|
+  config.api_key        = ENV["NURSE_ANDREA_API_KEY"]
+  config.log_level      = :warn
+  config.backfill_hours = 48
+  config.enabled        = !Rails.env.test?
+end
+```
+
+## Version history
+
+See [CHANGELOG.md](CHANGELOG.md).

data/app/controllers/nurse_andrea/status_controller.rb

@@ -0,0 +1,26 @@
+module NurseAndrea
+  class StatusController < ActionController::API
+    def show
+      render json: {
+        status:              "ok",
+        version:             NurseAndrea::VERSION,
+        rails_version:       defined?(Rails) ? Rails::VERSION::STRING : "n/a",
+        ruby_version:        RUBY_VERSION,
+        environment:         defined?(Rails) ? Rails.env : "unknown",
+        integration_token:   masked_token,
+        log_shipper_running: NurseAndrea::LogShipper.instance.running?,
+        metrics_running:     NurseAndrea::MetricsShipper.instance.running?,
+        timestamp:           Time.now.utc.iso8601,
+        capabilities:        %w[logs metrics backfill handshake]
+      }
+    end
+
+    private
+
+    def masked_token
+      token = NurseAndrea.config.api_key.to_s
+      return "not_configured" if token.empty?
+      "#{token[0..7]}..."
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+NurseAndrea::Engine.routes.draw do
+  get "/status", to: "status#show"
+end

data/lib/generators/nurse_andrea/install/install_generator.rb

@@ -0,0 +1,26 @@
+require "rails/generators"
+
+module NurseAndrea
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      desc "Creates a NurseAndrea initializer and mounts the status endpoint"
+
+      def create_initializer
+        template "nurse_andrea.rb.tt", "config/initializers/nurse_andrea.rb"
+      end
+
+      def mount_engine
+        route 'mount NurseAndrea::Engine => "/nurse_andrea"'
+      end
+
+      def show_next_steps
+        say "\nNurseAndrea installed!", :green
+        say "Next steps:", :bold
+        say "  1. Set NURSE_ANDREA_API_KEY in your environment"
+        say "  2. Get your API key from: https://app.nurseandrea.com/dashboard/integrations"
+        say "  3. Deploy and visit your onboarding wizard to verify the connection\n"
+      end
+    end
+  end
+end

data/lib/generators/nurse_andrea/install/templates/nurse_andrea.rb.tt

@@ -0,0 +1,16 @@
+NurseAndrea.configure do |c|
+  # Required: your integration token from the NurseAndrea dashboard
+  c.token = ENV["NURSE_ANDREA_TOKEN"]
+
+  # Required: the NurseAndrea host for this environment
+  c.host = ENV.fetch("NURSE_ANDREA_HOST", "https://nurseandrea.io")
+
+  # Optional: minimum log level to ship (default: :debug — ships everything)
+  # c.log_level = :warn
+
+  # Optional: disable in certain environments
+  # c.enabled = !Rails.env.test?
+
+  # Optional: how many hours of log history to backfill on first connect (default: 24)
+  # c.backfill_hours = 24
+end

data/lib/nurse_andrea/backfill.rb

@@ -0,0 +1,116 @@
+require "securerandom"
+require "json"
+
+module NurseAndrea
+  class Backfill
+    BATCH_SIZE  = 500
+    MARKER_FILE = ".nurse_andrea_backfill_done"
+
+    def self.run_async!
+      Thread.new { new.run }.tap do |t|
+        t.abort_on_exception = false
+        t.name = "NurseAndrea::Backfill"
+      end
+    end
+
+    def run
+      return unless should_run?
+
+      log_file = resolve_log_file
+      return unless log_file && File.exist?(log_file)
+
+      entries = parse_log_file(log_file)
+      ship_in_batches(entries)
+      mark_complete!
+    rescue => e
+      warn "[NurseAndrea] Backfill error: #{e.message}" if NurseAndrea.config.debug
+    end
+
+    private
+
+    def should_run?
+      return false unless NurseAndrea.config.enabled? && NurseAndrea.config.valid?
+      !File.exist?(marker_path)
+    end
+
+    def resolve_log_file
+      return NurseAndrea.config.log_file_path if NurseAndrea.config.log_file_path
+      if defined?(Rails)
+        Rails.root.join("log", "#{Rails.env}.log").to_s
+      end
+    end
+
+    def parse_log_file(path)
+      cutoff = Time.now.utc - (NurseAndrea.config.backfill_hours * 3600)
+      entries = []
+
+      File.foreach(path) do |line|
+        line = line.strip
+        next if line.empty?
+
+        entry = parse_line(line)
+        begin
+          next if entry[:timestamp] && Time.parse(entry[:timestamp]) < cutoff
+        rescue
+          nil
+        end
+
+        entries << entry
+      end
+
+      entries
+    rescue => e
+      warn "[NurseAndrea] Log parse error: #{e.message}" if NurseAndrea.config.debug
+      []
+    end
+
+    def parse_line(line)
+      parsed = JSON.parse(line)
+      {
+        level:     parsed["level"] || parsed["severity"] || "info",
+        message:   parsed["message"] || parsed["msg"] || line,
+        timestamp: parsed["time"] || parsed["timestamp"] || Time.now.utc.iso8601(3),
+        metadata:  { backfill: true }
+      }
+    rescue JSON::ParserError
+      {
+        level:     extract_level(line),
+        message:   line,
+        timestamp: Time.now.utc.iso8601(3),
+        metadata:  { backfill: true }
+      }
+    end
+
+    def extract_level(line)
+      if line.match?(/\b(ERROR|FATAL)\b/i) then "error"
+      elsif line.match?(/\bWARN\b/i)       then "warn"
+      elsif line.match?(/\bDEBUG\b/i)      then "debug"
+      else "info"
+      end
+    end
+
+    def ship_in_batches(entries)
+      client = HttpClient.new
+      entries.each_slice(BATCH_SIZE) do |batch|
+        client.post(NurseAndrea.config.ingest_url, {
+          logs: batch.map { |e|
+            { level: e[:level], message: e[:message], occurred_at: e[:timestamp], source: "backfill" }
+          }
+        })
+        sleep 0.1
+      end
+    end
+
+    def mark_complete!
+      File.write(marker_path, Time.now.utc.iso8601)
+    end
+
+    def marker_path
+      if defined?(Rails)
+        Rails.root.join(MARKER_FILE).to_s
+      else
+        File.join(Dir.pwd, MARKER_FILE)
+      end
+    end
+  end
+end

data/lib/nurse_andrea/configuration.rb

@@ -0,0 +1,49 @@
+module NurseAndrea
+  class Configuration
+    attr_accessor :api_key, :host, :timeout, :log_level, :batch_size,
+                  :flush_interval, :backfill_hours, :log_file_path,
+                  :enabled, :debug
+
+    LOG_LEVELS   = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }.freeze
+    DEFAULT_HOST = "https://nurseandrea.io"
+
+    def initialize
+      @host           = DEFAULT_HOST
+      @timeout        = 5
+      @log_level      = :debug
+      @batch_size     = 100
+      @flush_interval = 10
+      @backfill_hours = 24
+      @log_file_path  = nil
+      @enabled        = true
+      @debug          = false
+    end
+
+    alias_method :token,  :api_key
+    alias_method :token=, :api_key=
+
+    # All endpoint URLs derived from host
+    def ingest_url    = "#{normalised_host}/api/v1/ingest"
+    def metrics_url   = "#{normalised_host}/api/v1/metrics"
+    def traces_url    = "#{normalised_host}/api/v1/traces"
+    def handshake_url = "#{normalised_host}/api/v1/handshake"
+
+    def enabled?
+      @enabled
+    end
+
+    def min_log_level_int
+      LOG_LEVELS.fetch(log_level.to_sym, 0)
+    end
+
+    def valid?
+      !api_key.nil? && !api_key.to_s.strip.empty?
+    end
+
+    private
+
+    def normalised_host
+      host.to_s.chomp("/")
+    end
+  end
+end

data/lib/nurse_andrea/engine.rb

@@ -0,0 +1,7 @@
+require "rails/engine"
+
+module NurseAndrea
+  class Engine < Rails::Engine
+    isolate_namespace NurseAndrea
+  end
+end

data/lib/nurse_andrea/http_client.rb

@@ -0,0 +1,38 @@
+require "net/http"
+require "uri"
+require "json"
+
+module NurseAndrea
+  class HttpClient
+    def initialize
+      @api_key = NurseAndrea.config.api_key
+      @timeout = NurseAndrea.config.timeout
+    end
+
+    def post(url, body)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl      = uri.scheme == "https"
+      http.open_timeout  = @timeout
+      http.read_timeout  = @timeout
+
+      request = Net::HTTP::Post.new(uri.path)
+      request["Content-Type"]  = "application/json"
+      request["Authorization"] = "Bearer #{@api_key}"
+      request["User-Agent"]    = "nurse_andrea-ruby/#{NurseAndrea::VERSION}"
+      request.body = body.to_json
+
+      response = http.request(request)
+      success = response.code.to_i.between?(200, 299)
+
+      if NurseAndrea.config.debug && !success
+        warn "[NurseAndrea] HTTP #{response.code} from #{uri}: #{response.body.to_s[0..200]}"
+      end
+
+      success
+    rescue => e
+      warn "[NurseAndrea] HTTP error posting to #{url}: #{e.class}: #{e.message}" if NurseAndrea.config.debug
+      false
+    end
+  end
+end

data/lib/nurse_andrea/log_interceptor.rb

@@ -0,0 +1,49 @@
+require "logger"
+
+module NurseAndrea
+  class LogInterceptor < SimpleDelegator
+    SEV_LABEL = %w[DEBUG INFO WARN ERROR FATAL ANY].freeze
+
+    def initialize(original_logger)
+      super(original_logger)
+      @min_level = NurseAndrea.config.min_log_level_int
+    end
+
+    %w[debug info warn error fatal].each do |level|
+      define_method(level) do |progname = nil, &block|
+        add(Logger.const_get(level.upcase), nil, progname, &block)
+      end
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      result = super
+
+      return result unless NurseAndrea.config.enabled? && NurseAndrea.config.valid?
+      return result if severity.nil? || severity < @min_level
+
+      msg = message.nil? ? (block ? block.call : progname) : message
+      return result if msg.nil?
+
+      level_str = SEV_LABEL[severity]&.downcase || "unknown"
+
+      # Capture OpenTelemetry trace context if available
+      trace_metadata = {}
+      if defined?(OpenTelemetry) && OpenTelemetry.respond_to?(:tracer_provider)
+        span_context = OpenTelemetry::Trace.current_span&.context
+        if span_context&.valid?
+          trace_metadata[:trace_id] = span_context.hex_trace_id
+          trace_metadata[:span_id]  = span_context.hex_span_id
+        end
+      end
+
+      NurseAndrea::LogShipper.instance.enqueue(
+        level:     level_str,
+        message:   msg.to_s.strip,
+        timestamp: Time.now.utc.iso8601(3),
+        metadata:  { progname: progname&.to_s }.merge(trace_metadata).compact
+      )
+
+      result
+    end
+  end
+end

data/lib/nurse_andrea/log_shipper.rb

@@ -0,0 +1,79 @@
+require "singleton"
+require "securerandom"
+
+module NurseAndrea
+  class LogShipper
+    include Singleton
+
+    MAX_QUEUE_SIZE = 10_000
+
+    def initialize
+      @queue  = []
+      @mutex  = Mutex.new
+      @thread = nil
+    end
+
+    def start!
+      return if @thread&.alive?
+      @thread = Thread.new { flush_loop }
+      @thread.abort_on_exception = false
+      @thread.name = "NurseAndrea::LogShipper"
+    end
+
+    def stop!
+      @thread&.kill
+      flush!
+    end
+
+    def running?
+      @thread&.alive? || false
+    end
+
+    def enqueue(entry)
+      flush_now = @mutex.synchronize do
+        @queue.shift if @queue.size >= MAX_QUEUE_SIZE
+        @queue << entry
+        @queue.size >= NurseAndrea.config.batch_size
+      end
+      flush! if flush_now
+    end
+
+    def flush!
+      entries = @mutex.synchronize do
+        return if @queue.empty?
+        batch = @queue.dup
+        @queue.clear
+        batch
+      end
+      return if entries.nil? || entries.empty?
+
+      ship(entries)
+    end
+
+    private
+
+    def flush_loop
+      loop do
+        sleep NurseAndrea.config.flush_interval
+        flush!
+      rescue => e
+        warn "[NurseAndrea::LogShipper] Error in flush loop: #{e.message}" if NurseAndrea.config.debug
+      end
+    end
+
+    def ship(entries)
+      HttpClient.new.post(NurseAndrea.config.ingest_url, {
+        logs: entries.map { |e|
+          {
+            level:       e[:level],
+            message:     e[:message],
+            occurred_at: e[:timestamp],
+            source:      "nurse_andrea_gem",
+            batch_id:    SecureRandom.uuid,
+            payload:     e[:metadata] || {}
+          }
+        }
+      })
+    end
+  end
+end

data/lib/nurse_andrea/metrics_middleware.rb

@@ -0,0 +1,40 @@
+module NurseAndrea
+  class MetricsMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      return @app.call(env) unless NurseAndrea.config.enabled? && NurseAndrea.config.valid?
+      return @app.call(env) if env["PATH_INFO"]&.start_with?("/nurse_andrea")
+
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      status, headers, body = @app.call(env)
+      duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+
+      NurseAndrea::MetricsShipper.instance.enqueue(
+        name:      "http.server.duration",
+        value:     duration_ms,
+        unit:      "ms",
+        timestamp: Time.now.utc.iso8601(3),
+        tags: {
+          http_method: env["REQUEST_METHOD"],
+          http_status: status.to_s,
+          http_path:   normalize_path(env["PATH_INFO"])
+        }
+      )
+
+      [ status, headers, body ]
+    rescue => e
+      warn "[NurseAndrea] Middleware error: #{e.message}" if NurseAndrea.config.debug
+      raise
+    end
+
+    private
+
+    def normalize_path(path)
+      return "/" if path.nil? || path.empty?
+      path.gsub(%r{/\d+(/|$)}, '/:id\1')
+    end
+  end
+end

data/lib/nurse_andrea/metrics_shipper.rb

@@ -0,0 +1,78 @@
+require "singleton"
+require "securerandom"
+
+module NurseAndrea
+  class MetricsShipper
+    include Singleton
+
+    BATCH_SIZE     = 200
+    FLUSH_INTERVAL = 15
+
+    def initialize
+      @queue  = []
+      @mutex  = Mutex.new
+      @thread = nil
+    end
+
+    def start!
+      return if @thread&.alive?
+      @thread = Thread.new { flush_loop }
+      @thread.abort_on_exception = false
+      @thread.name = "NurseAndrea::MetricsShipper"
+    end
+
+    def stop!
+      @thread&.kill
+      flush!
+    end
+
+    def running?
+      @thread&.alive? || false
+    end
+
+    def enqueue(metric)
+      flush_now = @mutex.synchronize do
+        @queue << metric
+        @queue.size >= BATCH_SIZE
+      end
+      flush! if flush_now
+    end
+
+    def flush!
+      metrics = @mutex.synchronize do
+        return if @queue.empty?
+        batch = @queue.dup
+        @queue.clear
+        batch
+      end
+      return if metrics.nil? || metrics.empty?
+
+      ship(metrics)
+    end
+
+    private
+
+    def flush_loop
+      loop do
+        sleep FLUSH_INTERVAL
+        flush!
+      rescue => e
+        warn "[NurseAndrea::MetricsShipper] #{e.message}" if NurseAndrea.config.debug
+      end
+    end
+
+    def ship(metrics)
+      HttpClient.new.post(NurseAndrea.config.metrics_url, {
+        metrics: metrics.map { |m|
+          {
+            name:        m[:name],
+            value:       m[:value],
+            unit:        m[:unit],
+            tags:        m[:tags] || {},
+            occurred_at: m[:timestamp]
+          }
+        }
+      })
+    end
+  end
+end

data/lib/nurse_andrea/railtie.rb

@@ -0,0 +1,27 @@
+require "rails/railtie"
+
+module NurseAndrea
+  class Railtie < Rails::Railtie
+    initializer "nurse_andrea.insert_middleware", before: :build_middleware_stack do |app|
+      app.config.middleware.insert_before 0, NurseAndrea::MetricsMiddleware
+    end
+
+    initializer "nurse_andrea.wrap_logger", after: :initialize_logger do
+      next unless NurseAndrea.config.enabled? && NurseAndrea.config.valid?
+
+      Rails.logger = NurseAndrea::LogInterceptor.new(Rails.logger)
+      NurseAndrea::LogShipper.instance.start!
+      NurseAndrea::MetricsShipper.instance.start!
+    end
+
+    config.after_initialize do
+      next unless NurseAndrea.config.enabled? && NurseAndrea.config.valid?
+      NurseAndrea::Backfill.run_async!
+    end
+
+    at_exit do
+      NurseAndrea::LogShipper.instance.flush! rescue nil
+      NurseAndrea::MetricsShipper.instance.flush! rescue nil
+    end
+  end
+end

data/lib/nurse_andrea/version.rb

@@ -0,0 +1,3 @@
+module NurseAndrea
+  VERSION = "0.1.2"
+end

data/lib/nurse_andrea.rb

@@ -0,0 +1,27 @@
+require "nurse_andrea/version"
+require "nurse_andrea/configuration"
+require "nurse_andrea/http_client"
+require "nurse_andrea/log_interceptor"
+require "nurse_andrea/log_shipper"
+require "nurse_andrea/metrics_middleware"
+require "nurse_andrea/metrics_shipper"
+require "nurse_andrea/backfill"
+
+require "nurse_andrea/railtie" if defined?(Rails::Railtie)
+require "nurse_andrea/engine"  if defined?(Rails::Engine)
+
+module NurseAndrea
+  class << self
+    def configure
+      yield(config)
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def reset_config!
+      @config = nil
+    end
+  end
+end

data/nurse_andrea.gemspec

@@ -0,0 +1,28 @@
+require_relative "lib/nurse_andrea/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "nurse_andrea"
+  spec.version     = NurseAndrea::VERSION
+  spec.authors     = [ "Ago AI LLC" ]
+  spec.email       = [ "hello@nurseandrea.io" ]
+  spec.summary     = "Observability SDK for Rails — ships logs and metrics to NurseAndrea"
+  spec.description = "One-line integration to send your Rails app's logs and metrics to the NurseAndrea observability platform."
+  spec.homepage    = "https://nurseandrea.io"
+  spec.license     = "MIT"
+
+  spec.required_ruby_version = ">= 3.1"
+
+  spec.metadata = {
+    "homepage_uri"          => spec.homepage,
+    "source_code_uri"       => "https://github.com/narteyb/nurse-andrea",
+    "changelog_uri"         => "https://github.com/narteyb/nurse-andrea/blob/main/gems/nurse_andrea/CHANGELOG.md",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir["{app,config,lib}/**/*", "README.md", "CHANGELOG.md", "nurse_andrea.gemspec"]
+      .reject { |f| File.directory?(f) }
+  end
+
+  spec.require_paths = [ "lib" ]
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: nurse_andrea
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Ago AI LLC
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: One-line integration to send your Rails app's logs and metrics to the
+  NurseAndrea observability platform.
+email:
+- hello@nurseandrea.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- app/controllers/nurse_andrea/status_controller.rb
+- config/routes.rb
+- lib/generators/nurse_andrea/install/install_generator.rb
+- lib/generators/nurse_andrea/install/templates/nurse_andrea.rb.tt
+- lib/nurse_andrea.rb
+- lib/nurse_andrea/backfill.rb
+- lib/nurse_andrea/configuration.rb
+- lib/nurse_andrea/engine.rb
+- lib/nurse_andrea/http_client.rb
+- lib/nurse_andrea/log_interceptor.rb
+- lib/nurse_andrea/log_shipper.rb
+- lib/nurse_andrea/metrics_middleware.rb
+- lib/nurse_andrea/metrics_shipper.rb
+- lib/nurse_andrea/railtie.rb
+- lib/nurse_andrea/version.rb
+- nurse_andrea.gemspec
+homepage: https://nurseandrea.io
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://nurseandrea.io
+  source_code_uri: https://github.com/narteyb/nurse-andrea
+  changelog_uri: https://github.com/narteyb/nurse-andrea/blob/main/gems/nurse_andrea/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.9
+specification_version: 4
+summary: Observability SDK for Rails — ships logs and metrics to NurseAndrea
+test_files: []