standard_circuit 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8a58ef94e0f296c0e3b107fda1decfc29037324942c5326ec2fcfd1fdf19f2f
-  data.tar.gz: b3a78ae40f5a60c0e9754011eca3174ec4d489f61e51d41f81a6eb5a7efeb946
+  metadata.gz: ac355e3881c42900c272ba14d433216f4d8e6019e003e4b5bd52f84545c11c79
+  data.tar.gz: ffdb732b389d5b752deef02d6cdc82fd148af38e3e861d046876cce329e50d36
 SHA512:
-  metadata.gz: c9e4a015cf36e76ff7bece785930be035b323e4306897538750d5641237b0c34a931ba69f72aeb568456202b1472657d9e44c628967bbcd0bf2d240727c34a9b
-  data.tar.gz: 37a2b60ddb1488905ab5a01652ca41fd5f5452e55f689168041edb3dd46235503c31c23e92d51b154d86f1faaae3755aa506b05c15aef6f9e77a7463fff02ce3
+  metadata.gz: e2ffa97cfc68660ca8e32bd606df2251700f619f728969ce0e27ed485b6887eb6d8ecd6f1b641a0cea9d22c4842c3a5041a25b00bac97a84c37ea00ca78adf48
+  data.tar.gz: 8f245331cafaeb355b33e0ddd515bb23824713826d908544533959cd1f2dcb6c21d0160887370dadeef566a495d0474f66603095c0e1d93d1275f67c35f9f27d

data/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-07-30
+
+### Added
+- `config.sentry_criticality_levels` — opt in to criticality-aware Sentry reporting for the built-in Sentry subscriber. Accepts `true` (the recommended map `{ critical: :error, standard: :warning, optional: :info }`), a partial Hash merged over that map, or `nil` / `false` for the previous flat behaviour. In criticality-aware mode a circuit-open report also gains `circuit` / `circuit_criticality` tags and a stable `["circuit-open", <circuit>]` fingerprint, so Sentry alert rules can page on `circuit_criticality:critical` and group one issue per breaker. Invalid criticalities and non-symbolizable levels raise `ArgumentError` at configure time rather than failing silently at alert time.
+
+  **This is opt-in, and deliberately not the new default.** Both the level and the fingerprint feed Sentry's alerting and issue grouping, so flipping the map on at gem-upgrade time would silently re-page and re-group live issues in apps that never asked for it. Apps that leave `sentry_criticality_levels` unset get the 0.2.x report byte-for-byte — same `:warning` level, same message, no tags, no fingerprint. Host apps that hand-rolled this by setting `sentry_enabled = false` and registering their own alerter can now delete that class and set `sentry_enabled = true` + `sentry_criticality_levels = true` instead.
+- `isolate_namespace StandardCircuit` on the engine, bringing it in line with every other engine gem in the family. Verified non-breaking for the aggregate health route every consumer draws (`get "/health", to: "standard_circuit/health#show"`): that path is resolved by the *application's* route set through constant lookup, which isolation does not touch, and the new `spec/integration/health_route_boot_spec.rb` boots a real Rails app and requests the route end to end so a regression fails here rather than in a consumer after release. Safe specifically because this engine is library-only — no `config/routes.rb` for the isolated `default_scope` to scope, and no ActiveRecord models for the `standard_circuit_` `table_name_prefix` to apply to.
+
+  One consequence to know about: `StandardCircuit::HealthController` now picks up the engine's (empty) url helpers instead of the application's, so app path helpers used inside it — or inside a host subclass of it — need a `main_app.` prefix. The gem's controller only renders JSON, so nothing in-gem is affected.
+- README section on `data_store`, previously undocumented. Spells out that the `Stoplight::DataStore::Memory` default is **per-process** — thresholds count per worker, `/health` reports the serving process's view, and `force_open` / `reset!` are process-local — plus the shared-store alternative for apps that want cross-process state.
+- README section on Sentry reporting covering `sentry_enabled`, the new `sentry_criticality_levels` opt-in, and the "subscribe yourself" escape hatch.
+
+### Changed
+- The install generator now warns that the aggregate `get "/health", to: "standard_circuit/health#show"` route must be drawn **before** `mount StandardHealth::Engine => "/health"`. `StandardHealth::Engine` registers sub-paths only (`/alive`, `/ready`, `/diagnostics/env`) and never serves the aggregate tier itself, so an app that mounts it and assumes `/health` is covered silently has no aggregate tier — with no boot error and no failing route spec to reveal it. The warning appears in the initializer template, in the `--with-health-endpoint` health initializer next to the route line, and in the hint the generator prints. Same note added to the README's health-endpoint section.
+- `.github/workflows/ci.yml` follows the shared reusable workflow at `@v2` again, matching the rest of the gem family. The previous SHA pin carried a stale rationale: it claimed to restore pre-`rarebit-one/.github#14` job names for branch protection, but `main`'s protection now requires the *post*-#14 names (`ci / lint`, `ci / test-matrix (4.0.x)`) and the pinned revision's `reusable-gem-ci.yml` is byte-identical to `@v2` — so it was neither restoring old names nor changing any check name. It did honour `extra-lint-commands`, so the brakeman / bundler-audit gate was live throughout.
+
 ## [0.2.0] - 2026-04-28
 
 ### Added

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Rarebit One
+
+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

@@ -58,6 +58,48 @@ StandardCircuit.run(:stripe) do
 end
 ```
 
+## Circuit state storage (`data_store`)
+
+Circuit state (failure counts, colors, locks) lives in a Stoplight data store. StandardCircuit defaults to `Stoplight::DataStore::Memory.new`, which is **per-process**: each Puma worker, Sidekiq/SolidQueue worker, and console gets its own independent view of every circuit.
+
+That is the deliberate default for a Redis-free deployment, and it is usually the right one — a circuit exists to stop *this* process from hammering a dead upstream, and per-process thresholds mean one unlucky worker can't trip the breaker for everyone. But be explicit about what it implies:
+
+- Thresholds are counted per process, so an app with 4 web workers tolerates roughly 4× the configured `threshold` in aggregate before every worker has tripped.
+- `/health` reports the circuit colors of **the process that served the request**, so two consecutive probes can legitimately disagree while a circuit is tripping.
+- `force_open` / `force_closed` and `reset!` affect only the calling process — they are test and console tools, not an operational kill switch.
+
+Point `data_store` at a shared store if you want cross-process state instead:
+
+```ruby
+StandardCircuit.configure do |c|
+  # Default — per-process, no external dependency.
+  c.data_store = Stoplight::DataStore::Memory.new
+
+  # Shared across processes and hosts (requires the redis gem + a Redis server).
+  # c.data_store = Stoplight::DataStore::Redis.new(Redis.new(url: ENV["REDIS_URL"]))
+end
+```
+
+## Sentry reporting
+
+The built-in Sentry subscriber is on by default (`c.sentry_enabled = true`) and reports every circuit-open transition at a flat `:warning`, with the circuit name, colors, and error in `extra`.
+
+Set `sentry_criticality_levels` to derive the level from the circuit's registered `criticality` instead. That also adds `circuit` / `circuit_criticality` tags and a stable `["circuit-open", <circuit>]` fingerprint, so Sentry alert rules can route on criticality (e.g. page on `circuit_criticality:critical`) and group per circuit:
+
+```ruby
+StandardCircuit.configure do |c|
+  # { critical: :error, standard: :warning, optional: :info }
+  c.sentry_criticality_levels = true
+
+  # Or override part of that map — unlisted criticalities keep the default.
+  # c.sentry_criticality_levels = { optional: :debug }
+end
+```
+
+This is **opt-in, not the default**. Both the level and the fingerprint feed Sentry's alerting and issue grouping, so turning it on for existing apps at gem-upgrade time would silently change what pages and re-group open issues. Leaving `sentry_criticality_levels` unset keeps the flat `:warning` shape byte-for-byte.
+
+If you want something else entirely, set `c.sentry_enabled = false` and subscribe to `standard_circuit.circuit.opened` yourself — the payload carries `criticality`.
+
 ## Events
 
 Every circuit lifecycle moment is emitted as a Rails event. On Rails 8.1+ the canonical bus is `Rails.event`; on older Rails versions the gem transparently falls back to `ActiveSupport::Notifications`. Detection happens per-emit, so subscribers do not need to care which backend is live.
@@ -147,7 +189,14 @@ end
 
 The controller inherits from `ActionController::API` to sidestep app-level filters (authentication, bootstrap redirects, etc.) so probes can call it anonymously.
 
-See [`standard_circuit-design.md`](../standard_circuit-design.md) for the full design.
+**If your app also mounts `StandardHealth::Engine` at `/health`, draw the aggregate route first:**
+
+```ruby
+get "/health", to: "standard_circuit/health#show"        # aggregate — FIRST
+mount StandardHealth::Engine => "/health", as: :standard_health
+```
+
+`StandardHealth::Engine` registers sub-paths only (`/alive`, `/ready`, `/diagnostics/env`) — it never serves the aggregate tier itself. An app that mounts the engine and assumes `/health` is covered silently has no aggregate tier at all, with no boot error and no failing route spec to reveal it. The ordering is load-bearing; draw the aggregate route explicitly, first.
 
 ## License
 

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

@@ -67,6 +67,12 @@ module StandardCircuit
         say ""
         say '  get "/health", to: "standard_circuit/health#show"'
         say ""
+        say "If you also mount StandardHealth::Engine at \"/health\", draw the"
+        say "line above BEFORE the mount. That engine serves sub-paths only"
+        say "(/alive, /ready, /diagnostics/env), never the aggregate tier — so"
+        say "an app that mounts it and assumes \"/health\" is covered silently has"
+        say "no aggregate tier, with no boot error to warn you."
+        say ""
         say "The controller returns 503 when the rolled-up circuit health is"
         say ":critical and 200 otherwise — wire it up to your load balancer."
         say "=" * 79

data/lib/generators/standard_circuit/install/templates/health_initializer.rb.tt

@@ -6,6 +6,18 @@
 #
 #   get "/health", to: "standard_circuit/health#show"
 #
+# ORDERING IS LOAD-BEARING: if your app also mounts StandardHealth::Engine at
+# "/health", draw this aggregate route BEFORE the mount —
+#
+#   get "/health", to: "standard_circuit/health#show"        # aggregate — FIRST
+#   mount StandardHealth::Engine => "/health", as: :standard_health
+#
+# StandardHealth::Engine registers sub-paths only ("/alive", "/ready",
+# "/diagnostics/env") — it never serves the aggregate tier itself. So an app
+# that mounts the engine and assumes "/health" is covered has no aggregate tier
+# at all, and nothing says so: no boot error, and no failing route spec unless
+# one already exists. Draw this route explicitly, first.
+#
 # The endpoint renders StandardCircuit.health_report as JSON and returns
 # 503 when the rolled-up status is :critical (so orchestrators pull the
 # instance out of rotation) and 200 otherwise.

data/lib/generators/standard_circuit/install/templates/initializer.rb.tt

@@ -17,6 +17,17 @@ StandardCircuit.configure do |config|
   # Default: true
   # config.sentry_enabled = true
 
+  # Report circuit-open events at a Sentry level chosen from the circuit's
+  # criticality, and add `circuit` / `circuit_criticality` tags plus a stable
+  # ["circuit-open", <circuit>] fingerprint so Sentry alert rules can route and
+  # group by circuit. Opt-in: leaving this unset keeps the flat :warning
+  # reporting (no tags, no fingerprint) that earlier versions used.
+  #   true  -> { critical: :error, standard: :warning, optional: :info }
+  #   Hash  -> the above, merged with your overrides
+  # Default: nil (flat :warning)
+  # config.sentry_criticality_levels = true
+  # config.sentry_criticality_levels = { optional: :debug }
+
   # Prefix used for emitted metrics (e.g. "<prefix>.circuit_breaker",
   # "<prefix>.request"). Default: "external"
   # config.metric_prefix = "external"
@@ -80,4 +91,14 @@ StandardCircuit.configure do |config|
   # contract as the built-in subscribers.
 
   # config.add_notifier(->(name, payload) { MyTracer.record(name, payload) })
+
+  # ---------------------------------------------------------------------------
+  # Health endpoint (see --with-health-endpoint)
+  # ---------------------------------------------------------------------------
+  # The aggregate route is `get "/health", to: "standard_circuit/health#show"`.
+  # If your app also mounts StandardHealth::Engine at "/health", draw the
+  # aggregate route BEFORE the mount. That engine registers sub-paths only
+  # ("/alive", "/ready", "/diagnostics/env") and never serves the aggregate tier
+  # itself, so an app that mounts it and assumes "/health" is covered silently
+  # has no aggregate tier — no boot error, no failing route spec.
 end

data/lib/standard_circuit/config.rb

@@ -34,10 +34,11 @@ module StandardCircuit
     end
 
     attr_accessor :sentry_enabled, :metric_prefix, :data_store, :logger
-    attr_reader :circuits, :prefixes, :extra_notifiers
+    attr_reader :circuits, :prefixes, :extra_notifiers, :sentry_criticality_levels
 
     def initialize
       @sentry_enabled = true
+      @sentry_criticality_levels = nil
       @metric_prefix = "external"
       @data_store = Stoplight::DataStore::Memory.new
       @logger = nil
@@ -46,6 +47,22 @@ module StandardCircuit
       @extra_notifiers = []
     end
 
+    # Opt in to criticality-aware Sentry reporting for the built-in Sentry
+    # subscriber. Accepts:
+    #
+    #   nil / false  — (default) flat :warning for every circuit, no tags and
+    #                  no fingerprint. The 0.2.x behaviour.
+    #   true         — Notifiers::Sentry::DEFAULT_LEVELS
+    #                  ({ critical: :error, standard: :warning, optional: :info })
+    #   Hash         — DEFAULT_LEVELS merged with the given criticality => level
+    #                  pairs, so a partial map is enough.
+    #
+    # Stored normalized: the reader returns either nil or a frozen, complete
+    # criticality => level Hash.
+    def sentry_criticality_levels=(value)
+      @sentry_criticality_levels = normalize_sentry_criticality_levels(value)
+    end
+
     def reset_registry!
       @circuits.clear
       @prefixes.clear
@@ -90,6 +107,39 @@ module StandardCircuit
 
     private
 
+    def normalize_sentry_criticality_levels(value)
+      case value
+      when nil, false then nil
+      when true       then Notifiers::Sentry::DEFAULT_LEVELS
+      when Hash       then merge_sentry_criticality_levels(value)
+      else
+        raise ArgumentError,
+          "sentry_criticality_levels must be nil, true, false, or a Hash of " \
+          "criticality => Sentry level; got #{value.class}"
+      end
+    end
+
+    def merge_sentry_criticality_levels(map)
+      normalized = map.to_h do |criticality, level|
+        # Check symbolizability before coercing: a key like 42 would otherwise
+        # raise NoMethodError instead of the ArgumentError this setter promises.
+        criticality = criticality.to_sym if criticality.respond_to?(:to_sym)
+        unless CRITICALITIES.include?(criticality)
+          raise ArgumentError,
+            "invalid criticality #{criticality.inspect} in sentry_criticality_levels; " \
+            "must be one of #{CRITICALITIES.inspect}"
+        end
+        unless level.respond_to?(:to_sym)
+          raise ArgumentError,
+            "invalid Sentry level #{level.inspect} for criticality #{criticality.inspect}; " \
+            "must be a Symbol or String"
+        end
+        [ criticality, level.to_sym ]
+      end
+
+      Notifiers::Sentry::DEFAULT_LEVELS.merge(normalized).freeze
+    end
+
     def spec_for_prefix(name)
       key = name.to_s
       _matched_prefix, spec = @prefixes.find { |prefix, _| key.start_with?("#{prefix}_") }

data/lib/standard_circuit/engine.rb

@@ -9,6 +9,26 @@ module StandardCircuit
   # final state when the subscriber set is built. This is independent of
   # ActiveRecord — apps that don't load AR still need observability.
   class Engine < ::Rails::Engine
+    # Brings StandardCircuit in line with the other engine gems in the family.
+    # Safe here specifically because this engine is library-only:
+    #
+    # * No `config/routes.rb`, so the `default_scope` isolate_namespace applies
+    #   to the engine's own route set has nothing to scope.
+    # * No ActiveRecord models, so the `standard_circuit_` table_name_prefix it
+    #   defines on the StandardCircuit module applies to nothing.
+    # * The host-drawn route the convention prescribes —
+    #   `get "/health", to: "standard_circuit/health#show"` — resolves through
+    #   the *application's* route set by constant lookup, which isolation does
+    #   not touch. Verified by booting a real Rails app both ways (see
+    #   spec/integration/health_route_boot_spec.rb, which fails if this ever
+    #   regresses).
+    #
+    # One real consequence: `StandardCircuit::HealthController` now picks up the
+    # engine's (empty) url_helpers instead of the application's, so app path
+    # helpers inside it — or inside a host subclass of it — need a `main_app.`
+    # prefix. The controller only renders JSON, so nothing in-gem is affected.
+    isolate_namespace StandardCircuit
+
     initializer "standard_circuit.subscribers", after: :load_config_initializers do
       StandardCircuit.subscribers.setup!
     end

data/lib/standard_circuit/notifiers/sentry.rb

@@ -1,27 +1,88 @@
 module StandardCircuit
   module Notifiers
-    # Subscribes to standard_circuit.circuit.opened and forwards a warning-level
-    # message to Sentry. Other transitions are ignored — only RED matters for
-    # alerting.
+    # Subscribes to standard_circuit.circuit.opened and forwards a message to
+    # Sentry. Other transitions are ignored — only RED matters for alerting.
+    #
+    # Two reporting shapes:
+    #
+    # * **Flat** (default, and the only 0.2.x behaviour): every circuit reports
+    #   at `:warning` with the circuit's colors and error in `extra`. No tags,
+    #   no fingerprint.
+    # * **Criticality-aware** (opt in via `config.sentry_criticality_levels`):
+    #   the level is chosen from the circuit's registered criticality, and the
+    #   report gains `circuit` / `circuit_criticality` tags plus a stable
+    #   `["circuit-open", circuit]` fingerprint so Sentry alert rules can route
+    #   and group by circuit.
+    #
+    # Flat stays the default deliberately. Both the level and the fingerprint
+    # feed Sentry's alerting and grouping, so a gem bump must not silently
+    # re-page or re-group a host app's existing issues — see CHANGELOG.
     class Sentry
+      OPENED_EVENT = "standard_circuit.circuit.opened".freeze
+
+      # Level used in flat mode, and the fallback for an unrecognised
+      # criticality in criticality-aware mode.
+      DEFAULT_LEVEL = :warning
+
+      # The recommended criticality -> Sentry level mapping, used when
+      # `config.sentry_criticality_levels = true`. :critical is loud enough to
+      # page; :optional stays informational so a flapping nice-to-have
+      # upstream doesn't cry wolf.
+      DEFAULT_LEVELS = {
+        critical: :error,
+        standard: :warning,
+        optional: :info
+      }.freeze
+
+      # @param levels [Hash{Symbol=>Symbol}, nil] criticality -> level map.
+      #   nil (the default) selects flat :warning reporting.
+      def initialize(levels: nil)
+        @levels = levels
+      end
+
       def call(event_name, payload)
-        return unless event_name == "standard_circuit.circuit.opened"
+        return unless event_name == OPENED_EVENT
         return unless defined?(::Sentry) && ::Sentry.respond_to?(:capture_message)
 
+        @levels ? capture_criticality_aware(payload) : capture_flat(payload)
+      end
+
+      private
+
+      def capture_flat(payload)
         message = "Circuit breaker opened: #{payload[:circuit]}"
         ::Sentry.capture_message(
           message,
-          level: :warning,
-          extra: {
-            circuit: payload[:circuit],
-            from_color: payload[:from_color],
-            to_color: payload[:to_color],
-            error_class: payload[:error_class],
-            error_message: payload[:error_message]
-          }.compact
+          level: DEFAULT_LEVEL,
+          extra: base_extra(payload)
         )
         message
       end
+
+      def capture_criticality_aware(payload)
+        circuit = payload[:circuit].to_s
+        criticality = (payload[:criticality] || Config::DEFAULT_CRITICALITY).to_sym
+        message = "Circuit breaker opened: #{circuit} (#{criticality})"
+
+        ::Sentry.capture_message(
+          message,
+          level: @levels.fetch(criticality, DEFAULT_LEVEL),
+          tags: { circuit: circuit, circuit_criticality: criticality.to_s },
+          fingerprint: [ "circuit-open", circuit ],
+          extra: base_extra(payload).merge(circuit: circuit, criticality: criticality)
+        )
+        message
+      end
+
+      def base_extra(payload)
+        {
+          circuit: payload[:circuit],
+          from_color: payload[:from_color],
+          to_color: payload[:to_color],
+          error_class: payload[:error_class],
+          error_message: payload[:error_message]
+        }.compact
+      end
     end
   end
 end

data/lib/standard_circuit/subscribers.rb

@@ -72,7 +72,7 @@ module StandardCircuit
     def internal_subscribers
       config = StandardCircuit.config
       list = [ Notifiers::Logger.new(config.logger) ]
-      list << Notifiers::Sentry.new if config.sentry_enabled
+      list << Notifiers::Sentry.new(levels: config.sentry_criticality_levels) if config.sentry_enabled
       list << Notifiers::Metrics.new(metric_prefix: config.metric_prefix)
       list
     end

data/lib/standard_circuit/version.rb

@@ -1,3 +1,3 @@
 module StandardCircuit
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: standard_circuit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jaryl Sim
@@ -117,7 +117,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- MIT-LICENSE
+- LICENSE
 - README.md
 - Rakefile
 - lib/active_storage/service/standard_circuit_s3_service.rb

data/MIT-LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Jaryl Sim
-
-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.