realuptime-errors 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cfb6b588d319a4a1ceb6dd9a50d0520b494b4e1066056ce4b87261c97237c130
+  data.tar.gz: a5026d3e87519f3f6ddd140da1e25433b410c970548499f89a5e439d8de96ea8
+SHA512:
+  metadata.gz: 970d101abb8765cff0170a9a19fcf5a1b82697349334c6a463d26ed56f7520e0fb623e91e80b80c27090dee79b0076f55e2b13921103056e186ac5021e67cddc
+  data.tar.gz: c05b0bffcd6ca1079e4c278c132fc8a090b73caf4796b5c7a90bcca78fcedf6598cf72b65760bb281e4ee1b2030dbedd72e1c2946cdf213cc900bc52a17cee25

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RealUptime
+
+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,94 @@
+# realuptime-errors (Ruby)
+
+Zero-dependency error tracking SDK for Ruby, with Rails, Rack and Sidekiq
+integrations: part of [RealUptime Errors](https://realuptime.io/error-tracking).
+
+This is a **mirror**. It is published from `packages/errors-ruby` in the
+[realuptime monorepo](https://github.com/RealUptimeHQ/realuptime) by
+`scripts/publish-sdk-mirrors.mjs` and is not edited directly; open issues
+and PRs against this repo, but expect source changes to land here after
+they merge upstream.
+
+## Install
+
+Installs straight from GitHub today. npm, PyPI, RubyGems, and Packagist packages are coming; this note disappears the day they ship.
+
+```ruby
+# Gemfile
+gem "realuptime-errors", git: "https://github.com/RealUptimeHQ/realuptime-errors-ruby"
+```
+
+## Usage
+
+```ruby
+require "realuptime/errors"
+
+Realuptime::Errors.init(
+  dsn: "https://realuptime.io/api/errors/v1/ingest/rue_...",  # from your project's dashboard
+  release: "v2.4.1",
+  environment: "production"
+)
+
+Realuptime::Errors.capture_exception(some_error)
+```
+
+Rails: `gem "realuptime-errors", git: "...", require: "realuptime/errors/rails"`,
+then set `Rails.application.config.realuptime_errors.dsn` (or
+`ENV["REALUPTIME_ERRORS_DSN"]`); the Railtie installs the Rack middleware
+and the ActiveJob hook.
+Rack: `use Realuptime::Errors::RackMiddleware`
+Sidekiq: `require "realuptime/errors/sidekiq"; Realuptime::Errors::Sidekiq.install`
+
+## What this SDK actually does
+
+- **Never raises out of a public method.** Every entry point catches
+  everything; a broken SDK logs once to stderr (prefixed
+  `[realuptime-errors]`) and goes quiet. An error tracker that crashes the
+  app it watches is worse than none.
+- **Scrubs PII by default, client-side**, before anything serializes:
+  `Authorization`/`Proxy-Authorization`/`Cookie`/`Set-Cookie` headers are
+  replaced whole; card-shaped digit runs (Luhn-checked), JWTs, prefixed API
+  keys, and long hex/base64 runs are pattern-scrubbed anywhere they appear
+  in the message, request context, breadcrumbs, tags and context values.
+  `user.email` and `user.username` are removed unless opted back in by
+  name with `allow_fields: ["user.email"]`; there is no global "disable
+  scrubbing" switch, by design. The vectors in `scrub-vectors.json` are
+  the same file the JS and Python SDKs and the server are tested against.
+- **Never silently drops.** The in-memory buffer (200 events) evicts the
+  oldest event when full, counts every eviction, and reports the count on
+  the next successful batch, so drops show up on your dashboard instead of
+  disappearing.
+- **Standard library only** (`json`, `net/http`, `uri`, `time`,
+  `rbconfig`), checked by `test/wire_contract_test.rb`'s require
+  allow-list scan; the gemspec declares zero runtime dependencies.
+- **Background delivery** on one thread per process (re-spawned after a
+  fork), exponential backoff 5s to 300s, over-quota pause until the window
+  resets, revoked key disables for the process. `Realuptime::Errors.flush`
+  is synchronous and runs at exit.
+
+## API
+
+| Method | Notes |
+| --- | --- |
+| `init(dsn:, release: nil, environment: nil, allow_fields: nil, capture_unhandled: true, send_device_info: true, background: true)` | Installs an `at_exit` reporter unless `capture_unhandled: false`. Safe to call twice; a missing DSN logs once and stays inert. |
+| `capture_exception(exc, request: nil, fingerprint: nil, release: nil, environment: nil, user: nil, tags: nil, context: nil)` | Reports an exception. |
+| `capture_message(message, ...)` | Reports a plain message. |
+| `set_user(id:, email:, username:)` / `set_tag(k, v)` / `set_tags(h)` / `set_context(k, v)` | Sticky identity, tags and context for every later event. |
+| `add_breadcrumb(message, category: nil, data: nil)` | Bounded trail (last 20), rides the next event. |
+| `flush` | Delivers anything buffered, synchronously. |
+| `RackMiddleware` / `Rails::RailsMiddleware` / `Sidekiq::ServerMiddleware` | Capture unhandled exceptions with minimal request or job context, then re-raise. |
+
+## Tests
+
+```bash
+ruby -Ilib -Itest -e 'Dir["test/*_test.rb"].each { |f| require "./#{f}" }'
+```
+
+## Version
+
+This mirror tracks SDK_VERSION `0.1.0` in `lib/realuptime/errors/version.rb`,
+the string every event actually carries on the wire.
+
+## License
+
+MIT, see [LICENSE](./LICENSE).

data/lib/realuptime/errors/rack.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Realuptime
+  module Errors
+    # Plain Rack middleware: captures an exception escaping the app below it
+    # with the default minimal request context (method, path; the status is
+    # unknown mid-flight and omitted rather than guessed), then RE-RAISES.
+    # The middleware reports; the server keeps deciding what a 500 looks
+    # like. Never headers, never cookies, never bodies: the request capture
+    # is the same minimal default the JS and Python SDKs use.
+    #
+    #   use Realuptime::Errors::RackMiddleware
+    #
+    # Also reports an exception a downstream framework swallowed into
+    # env["rack.exception"] / env["action_dispatch.exception"] (Rails's
+    # ShowExceptions sets the latter when it renders its own error page),
+    # so a Rails 500 that never propagates still gets captured. The same
+    # exception object is reported once, not twice.
+    #
+    # Zero-dependency: this file never requires "rack"; a Rack app is any
+    # object answering call(env).
+    class RackMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        response = @app.call(env)
+        swallowed = env["action_dispatch.exception"] || env["rack.exception"]
+        report(swallowed, env) if swallowed.is_a?(Exception)
+        response
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        report(e, env)
+        raise
+      end
+
+      private
+
+      def report(exc, env)
+        return if already_reported?(exc)
+
+        Realuptime::Errors.capture_exception(exc, request: RackMiddleware.request_context(env))
+      rescue StandardError
+        nil
+      end
+
+      def already_reported?(exc)
+        return true if exc.instance_variable_get(:@__realuptime_reported)
+
+        exc.instance_variable_set(:@__realuptime_reported, true)
+        false
+      rescue StandardError
+        false
+      end
+
+      # Method + path from a Rack env, nothing else. Shared with the Rails
+      # and Sidekiq integrations so every entry point captures identically.
+      def self.request_context(env)
+        return nil unless env.is_a?(Hash)
+
+        request = {}
+        method = env["REQUEST_METHOD"]
+        request["method"] = method.to_s if method
+        path = env["PATH_INFO"]
+        path = "#{env["SCRIPT_NAME"]}#{path}" if env["SCRIPT_NAME"] && !env["SCRIPT_NAME"].to_s.empty?
+        request["path"] = path.to_s if path
+        request.empty? ? nil : request
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/realuptime/errors/rails.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "realuptime/errors"
+
+module Realuptime
+  module Errors
+    # Rails integration (REA-255). Feature-detected: this file never
+    # requires "rails"; the Railtie at the bottom is defined only when
+    # ::Rails::Railtie already exists, so requiring this file outside Rails
+    # is harmless and the helpers here are testable without it.
+    #
+    #   # Gemfile
+    #   gem "realuptime-errors", require: "realuptime/errors/rails"
+    #
+    #   # config/initializers/realuptime_errors.rb (or ENV REALUPTIME_ERRORS_DSN)
+    #   Rails.application.config.realuptime_errors.dsn = "https://realuptime.io/api/errors/v1/ingest/rue_..."
+    #   Rails.application.config.realuptime_errors.release = ENV["GIT_SHA"]
+    #
+    # What the Railtie installs, all through the ONE capture/scrub/transport
+    # path a plain init gives:
+    #   - RailsMiddleware at the outermost position of the Rack stack: an
+    #     exception that escapes, or one Rails swallowed into its own error
+    #     page (action_dispatch.exception), is reported ONCE with method,
+    #     path and the matched controller#action as the route template.
+    #   - an ActiveJob around_perform hook that reports a job's unhandled
+    #     exception with the job class as the fingerprint key and re-raises,
+    #     so retry_on / discard_on keep working exactly as before. A job that
+    #     retries reports each failed attempt; that is the honest count.
+    #   - init itself from config.realuptime_errors / ENV when the app did
+    #     not call Realuptime::Errors.init in an initializer.
+    module Rails
+      FRAMEWORK_TAG = { "framework" => "rails" }.freeze
+
+      # Rack-level context plus the matched controller#action, the grouping
+      # key Rails exposes without any user-supplied bytes. path_parameters
+      # VALUES (the :id etc.) are never forwarded; only the controller and
+      # action names are.
+      def self.request_context(env)
+        request = RackMiddleware.request_context(env) || {}
+        params = env.is_a?(Hash) ? env["action_dispatch.request.path_parameters"] : nil
+        if params.is_a?(Hash)
+          controller = params[:controller] || params["controller"]
+          action = params[:action] || params["action"]
+          request["route"] = "#{controller}##{action}" if controller && action
+        end
+        request.empty? ? nil : request
+      rescue StandardError
+        nil
+      end
+
+      class RailsMiddleware < RackMiddleware
+        private
+
+        def report(exc, env)
+          return if already_reported?(exc)
+
+          Realuptime::Errors.capture_exception(exc, request: Realuptime::Errors::Rails.request_context(env),
+                                                    tags: FRAMEWORK_TAG)
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Reports a job's failure and re-raises. Usable without ActiveJob
+      # (tests, or a hand-rolled job runner): yield the work.
+      def self.perform_reporting(job)
+        yield
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        begin
+          job_name = job.class.name.to_s
+          Realuptime::Errors.capture_exception(
+            e,
+            fingerprint: ["active_job", job_name, e.class.name.to_s],
+            tags: { "framework" => "active_job", "job" => job_name }
+          )
+        rescue StandardError
+          nil
+        end
+        raise
+      end
+
+      # `include`d into ActiveJob::Base by the Railtie.
+      module ActiveJobExtension
+        def self.included(base)
+          return unless base.respond_to?(:around_perform)
+
+          base.around_perform do |job, block|
+            Realuptime::Errors::Rails.perform_reporting(job) { block.call }
+          end
+        end
+      end
+
+      # Resolves init options from config.realuptime_errors (any object
+      # answering [] or the dotted accessors) and ENV. Returns nil when no
+      # DSN is configured anywhere, so the Railtie stays inert rather than
+      # logging on every boot of an app that has not opted in.
+      def self.options_from(config, env = ENV, rails_env = nil)
+        read = lambda do |key|
+          value = nil
+          if config.respond_to?(:[])
+            value = begin
+              config[key]
+            rescue StandardError
+              nil
+            end
+          end
+          value = config.public_send(key) if value.nil? && config.respond_to?(key)
+          value
+        end
+        dsn = read.call(:dsn) || env["REALUPTIME_ERRORS_DSN"]
+        return nil if dsn.nil? || dsn.to_s.empty?
+
+        {
+          dsn: dsn.to_s,
+          release: read.call(:release) || env["REALUPTIME_RELEASE"],
+          environment: read.call(:environment) || rails_env,
+          allow_fields: read.call(:allow_fields),
+          send_device_info: read.call(:send_device_info).nil? ? true : read.call(:send_device_info)
+        }
+      end
+
+      if defined?(::Rails::Railtie)
+        class Railtie < ::Rails::Railtie
+          config.realuptime_errors = ActiveSupport::OrderedOptions.new if defined?(ActiveSupport::OrderedOptions)
+
+          initializer "realuptime_errors.middleware" do |app|
+            app.config.middleware.insert_before(0, Realuptime::Errors::Rails::RailsMiddleware)
+          end
+
+          initializer "realuptime_errors.active_job" do
+            ActiveSupport.on_load(:active_job) { include Realuptime::Errors::Rails::ActiveJobExtension }
+          end
+
+          config.after_initialize do |app|
+            next if Realuptime::Errors.initialized?
+
+            options = Realuptime::Errors::Rails.options_from(app.config.realuptime_errors, ENV, ::Rails.env.to_s)
+            Realuptime::Errors.init(**options) if options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/realuptime/errors/scrub.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Realuptime
+  module Errors
+    # PII scrub-by-default, client-side (docs/errors-plan.md, "PII
+    # scrub-by-default, specified"). A byte-for-byte port of
+    # packages/errors-js/scrub.ts and packages/errors-py/realuptime_errors.py's
+    # scrub half; the shared vectors (scrub-vectors.json, vendored into this
+    # gem and asserted byte-identical to packages/errors-js/scrub-vectors.json
+    # by test/vendored_vectors_test.rb) pin all four implementations -- JS,
+    # Python, this one, and the server's second net -- to identical output.
+    #
+    # The five pattern rules, in the shared order:
+    #   1. JWT three-dot shape
+    #   2. prefixed keys (sk_/pk_/rk_/ghp_/gho_/ghs_/xox?_/rua_/rue_/ru_live_)
+    #   3. card-shaped digit runs, 13-19 digits, Luhn-checked
+    #   4. long hex runs (32+)
+    #   5. long base64-ish runs (40+)
+    #
+    # REMOVAL (value replaced whole) unless allow-listed by name:
+    #   - headers authorization / proxy-authorization / cookie / set-cookie
+    #   - identity (wire v2): user.email and user.username. user.id is NOT
+    #     removed; an opaque id in the customer's own key space is not
+    #     contact data, and it is what makes "how many users hit this"
+    #     answerable.
+    module Scrub
+      SCRUBBED = "[scrubbed]"
+
+      REMOVED_HEADERS = %w[authorization proxy-authorization cookie set-cookie].freeze
+      REMOVED_USER_FIELDS = %w[user.email user.username].freeze
+
+      JWT_RE = /\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\b/.freeze
+      PREFIXED_KEY_RE = /\b(?:sk|pk|rk|ghp|gho|ghs|xox[a-z]|rua|rue|ru_live)_[A-Za-z0-9_-]{8,}/.freeze
+      CARD_RE = /(?<!\d)(?:\d[ -]?){12,18}\d(?!\d)/.freeze
+      HEX_RE = /\b[0-9a-fA-F]{32,}\b/.freeze
+      BASE64_RE = /(?<![A-Za-z0-9+_=-])[A-Za-z0-9+_-]{40,}={0,2}/.freeze
+
+      module_function
+
+      def luhn_valid?(digits)
+        total = 0
+        double = false
+        digits.reverse.each_char do |ch|
+          d = ch.ord - 48
+          if double
+            d *= 2
+            d -= 9 if d > 9
+          end
+          total += d
+          double = !double
+        end
+        (total % 10).zero?
+      end
+
+      # The five pattern rules over one string. Pure.
+      def scrub_string(value)
+        out = value.gsub(JWT_RE, SCRUBBED)
+        out = out.gsub(PREFIXED_KEY_RE, SCRUBBED)
+        out = out.gsub(CARD_RE) do |run|
+          digits = run.delete(" -")
+          digits.length >= 13 && digits.length <= 19 && luhn_valid?(digits) ? SCRUBBED : run
+        end
+        out = out.gsub(HEX_RE, SCRUBBED)
+        out.gsub(BASE64_RE, SCRUBBED)
+      end
+
+      # A flat string map (tags, custom context, device, frame locals):
+      # VALUES pass the pattern rules, KEYS are left alone (a key is a label
+      # the integrator chose).
+      def scrub_string_map(value)
+        return value unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(name, entry), out|
+          out[name] = entry.is_a?(String) ? scrub_string(entry) : entry
+        end
+      end
+
+      def scrub_breadcrumb(crumb)
+        return crumb unless crumb.is_a?(Hash)
+
+        out = crumb.dup
+        out["message"] = scrub_string(out["message"]) if out["message"].is_a?(String)
+        out["data"] = scrub_string_map(out["data"]) if out["data"].is_a?(Hash)
+        out
+      end
+
+      def scrub_user(user, allowed)
+        return user unless user.is_a?(Hash)
+
+        out = user.dup
+        out["id"] = scrub_string(out["id"]) if out["id"].is_a?(String)
+        REMOVED_USER_FIELDS.each do |field|
+          key = field.sub("user.", "")
+          value = out[key]
+          next unless value.is_a?(String)
+
+          out[key] = allowed.include?(field) ? scrub_string(value) : SCRUBBED
+        end
+        out
+      end
+
+      def scrub_frame(frame)
+        return frame unless frame.is_a?(Hash)
+        return frame unless frame["contextLine"] || frame["preContext"] || frame["postContext"] || frame["vars"]
+
+        out = frame.dup
+        out["contextLine"] = scrub_string(out["contextLine"]) if out["contextLine"].is_a?(String)
+        %w[preContext postContext].each do |key|
+          lines = out[key]
+          out[key] = lines.map { |line| line.is_a?(String) ? scrub_string(line) : line } if lines.is_a?(Array)
+        end
+        out["vars"] = scrub_string_map(out["vars"]) if out["vars"].is_a?(Hash)
+        out
+      end
+
+      # Scrubs one wire event (string-keyed Hash). Returns a new Hash; never
+      # mutates the input.
+      def scrub_event(event, allow_fields = nil)
+        allowed = (allow_fields || []).map { |f| f.to_s.downcase }
+        out = event.dup
+        out["message"] = scrub_string(out["message"]) if out["message"].is_a?(String)
+        out["breadcrumbs"] = out["breadcrumbs"].map { |c| scrub_breadcrumb(c) } if out["breadcrumbs"].is_a?(Array)
+        out["frames"] = out["frames"].map { |f| scrub_frame(f) } if out["frames"].is_a?(Array)
+        %w[tags context device].each do |key|
+          out[key] = scrub_string_map(out[key]) if out[key].is_a?(Hash)
+        end
+        out["user"] = scrub_user(out["user"], allowed) if out["user"].is_a?(Hash)
+        request = out["request"]
+        if request.is_a?(Hash)
+          request = request.dup
+          request["path"] = scrub_string(request["path"]) if request["path"].is_a?(String)
+          request["route"] = scrub_string(request["route"]) if request["route"].is_a?(String)
+          headers = request["headers"]
+          if headers.is_a?(Hash)
+            request["headers"] = headers.each_with_object({}) do |(name, value), scrubbed|
+              lower = name.to_s.downcase
+              scrubbed[name] = if REMOVED_HEADERS.include?(lower) && !allowed.include?(lower)
+                                 SCRUBBED
+                               else
+                                 value.is_a?(String) ? scrub_string(value) : value
+                               end
+            end
+          end
+          out["request"] = request
+        end
+        out
+      end
+    end
+  end
+end

data/lib/realuptime/errors/sidekiq.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "realuptime/errors"
+
+module Realuptime
+  module Errors
+    # Sidekiq server middleware (REA-255). Feature-detected: this file never
+    # requires "sidekiq"; `install` only touches ::Sidekiq when it is
+    # already loaded and raises a clear message otherwise, the same shape as
+    # the Python SDK's Celery hook.
+    #
+    #   # config/initializers/sidekiq.rb
+    #   require "realuptime/errors/sidekiq"
+    #   Realuptime::Errors::Sidekiq.install
+    #
+    # Or add the middleware by hand:
+    #
+    #   Sidekiq.configure_server do |config|
+    #     config.server_middleware { |chain| chain.add Realuptime::Errors::Sidekiq::ServerMiddleware }
+    #   end
+    #
+    # A job's unhandled exception is reported with the worker class as the
+    # fingerprint key (so "ArgumentError in ChargeWorker" and "ArgumentError
+    # in MailWorker" never collapse into one issue), a framework tag, the
+    # worker class and queue as tags, then RE-RAISED so Sidekiq's own retry
+    # and dead-set handling is untouched. Job ARGUMENTS are never captured:
+    # that is where the customer's users' data lives. Sidekiq's retry count
+    # rides as a tag so "first failure" and "24th retry" are tellable apart.
+    # Every retry reports its own event; that is the honest count.
+    module Sidekiq
+      class ServerMiddleware
+        def call(worker, job, queue)
+          yield
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Realuptime::Errors::Sidekiq.report(e, worker, job, queue)
+          raise
+        end
+      end
+
+      def self.report(exc, worker, job, queue)
+        worker_name = job.is_a?(Hash) && job["wrapped"] ? job["wrapped"].to_s : worker.class.name.to_s
+        tags = { "framework" => "sidekiq", "worker" => worker_name }
+        tags["queue"] = queue.to_s if queue
+        if job.is_a?(Hash) && job.key?("retry_count")
+          tags["retry_count"] = job["retry_count"].to_s
+        end
+        Realuptime::Errors.capture_exception(
+          exc,
+          fingerprint: ["sidekiq", worker_name, exc.class.name.to_s],
+          tags: tags
+        )
+      rescue StandardError
+        nil
+      end
+
+      # Adds the middleware to Sidekiq's server chain. Raises a RuntimeError
+      # naming the fix if Sidekiq is not loaded, rather than failing at
+      # require time. Idempotent: Sidekiq's chain dedupes by class.
+      def self.install
+        unless defined?(::Sidekiq) && ::Sidekiq.respond_to?(:configure_server)
+          raise "Realuptime::Errors::Sidekiq.install requires Sidekiq to be loaded first (require \"sidekiq\")."
+        end
+
+        ::Sidekiq.configure_server do |config|
+          config.server_middleware { |chain| chain.add ServerMiddleware }
+          # Flush what the worker buffered before the process exits; Sidekiq
+          # fires :shutdown on a clean stop (TSTP/TERM), which is where a
+          # last in-flight batch would otherwise be lost.
+          config.on(:shutdown) { Realuptime::Errors.flush } if config.respond_to?(:on)
+        end
+        true
+      end
+    end
+  end
+end