closeyourit-ruby 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d77ef65ad83c3890320e2c3c3a002a6708ef52d223204da4b553ac75ec58c4b9
-  data.tar.gz: 4bc0274665e54f19fe33d6e379270f31802a71317075ceae65fecdd4b8a6d66c
+  metadata.gz: c46a549b542395326541c9def86cc019d5cd9620fef9c8f4584c90543ca1b179
+  data.tar.gz: 5ac2011a99d7be1d09a751334832154cf1d23765fe8527333adecda9862f50c1
 SHA512:
-  metadata.gz: cc89f3b0f20d8781b5a963b9fda04935b735500612db5883b29f86abc92bc560a452abc133db66859b919cdfcd8994ff6c4891fdcafe39a6c7878a960c74b627
-  data.tar.gz: 5b55acc5e39e78e9fc875e6cbfd32dfce56bbb9e27d600ec30f86a6d27d12660c1c61195a28c32f32ac22b418c78ac9d41e83af8bbdbd26f96781d740bd6f1cd
+  metadata.gz: 95b4271a533b85cb3d9cf0bf718f08b07a87ce180cd00c03fcc82c30cf24047bc240d1ad572be09bac04402b00ecb728e87250905d28666d443fd22d65111981
+  data.tar.gz: 9210728ff21f26c59b49a31007a068f1f3dd334214c2f67f5eb7aa9ce7b418ecdec3f6c1c9cc6b2935e950cded2252ebc417183c3c4518b7d8a4ca130d9a9a44

data/README.md

@@ -52,7 +52,7 @@ In CloseYourIt, area **Member → Project → tokens**, crea un token: ottieni i
 ```ruby
 # config/initializers/closeyourit.rb
 CloseYourIt.init do |c|
-  c.endpoint_url = ENV["CLOSEYOURIT_ENDPOINT_URL"]   # es. https://www.closeyour.it (host canonico)
+  c.endpoint_url = ENV["CLOSEYOURIT_ENDPOINT_URL"]   # es. https://app.closeyour.it (host canonico)
   c.token        = ENV["CLOSEYOURIT_TOKEN"]          # Bearer secret del Projects::Token
   c.project_id   = ENV["CLOSEYOURIT_PROJECT_ID"]     # UUID del progetto su CloseYourIt
   c.environment  = Rails.env
@@ -62,9 +62,8 @@ end
 **Senza `endpoint_url` / `token` / `project_id` la gemma è no-op** (nessun invio, nessun overhead). In
 `production` un `endpoint_url` `http://` viene rifiutato (no-op + warning): il token viaggerebbe in chiaro.
 
-> **Endpoint:** usa l'host canonico **`https://www.closeyour.it`**. La gemma segue fino a 2 redirect su POST
-> (preservando metodo e body), quindi anche l'apex `https://closeyour.it` (301 → www) funziona — ma puntare
-> direttamente a www risparmia un hop per ogni evento.
+> **Endpoint:** usa l'host canonico **`https://app.closeyour.it`**. Le installazioni già configurate su
+> `https://www.closeyour.it` continuano a funzionare: l'ingest su `www` resta inoltrato all'app.
 
 ### Opzioni
 
@@ -84,7 +83,9 @@ end
 | `slow_query_threshold_ms` | `100` | Soglia query lente |
 | `excluded_query_patterns` | `solid_queue_`, `solid_cache_`, `solid_cable_` | Query da NON misurare come rallentamento — **Regexp** (pattern) o **String** (testo letterale). Vale solo per la misura: breadcrumb e profiling N+1 vedono tutto |
 | `slow_method_threshold_ms` | `200` | Soglia metodi lenti |
+| `capture_method_arguments` | `false` | Allega gli argomenti di `measure`/`monitor` ai `slow_method`. **Attenzione**: gli argomenti sono spesso dati personali; la gemma redige chiavi sensibili, credenziali e `scrub_message_patterns`, non il resto |
 | `capture_request` | `true` | Cattura il contesto HTTP della richiesta (method/url/header allowlist) |
+| `capture_request_body` | `true` | Allega i parametri del body (`request.data`) all'errore, scrubbati. Vale **solo con `send_pii = true`**: con la privacy spenta il body non parte mai |
 | `request_header_allowlist` | `Accept`, `Content-Type`, `User-Agent`, `Referer` | Header inviati (mai Authorization/Cookie) |
 | `breadcrumbs_enabled` | `true` | Cronologia (query offuscate + `add_breadcrumb`) allegata all'errore |
 | `max_breadcrumbs` | `100` | Dimensione max del ring buffer breadcrumbs |
@@ -92,7 +93,7 @@ end
 | `report_active_job_errors` | `true` | Cattura gli errori dei job ActiveJob/Solid Queue/Sidekiq |
 | `send_pii` | `false` | Master switch PII |
 | `obfuscate_sql` | `true` | Maschera i literal nello SQL |
-| `filter_parameters` | `[]` | Chiavi extra da redarre (mergiate con quelle di Rails) |
+| `filter_parameters` | `[]` | Chiavi extra da redarre, in aggiunta a `Rails.application.config.filter_parameters` (unite automaticamente dalla Railtie) |
 | `scrub_message_patterns` | `[]` | Regexp **aggiuntive** da redarre da messaggi d'eccezione **e da `message` dei log**; le credenziali `Bearer`/`Basic`/`Token` sono già redatte di serie |
 | `logs_enabled` | `true` | Master switch dello stream di log strutturato |
 | `logs_min_level` | `:info` | Soglia minima: i log sotto (es. `debug`) non vengono inviati |
@@ -155,7 +156,9 @@ end
 
 Un Rack middleware allega a ogni evento il contesto HTTP della richiesta: **method**, **url** (senza
 query string) e gli **header dell'allowlist** (`request_header_allowlist`, mai Authorization/Cookie).
-Query string e IP solo con `send_pii`. Lo scope è resettato a fine richiesta (niente bleed tra request).
+Query string, IP e **parametri del body** (`request.data`, scrubbati, estratti solo quando scoppia
+l'errore; `capture_request_body` li spegne) solo con `send_pii`. Lo scope è resettato a fine richiesta
+(niente bleed tra request).
 
 ### Background job + errori handled (automatico, con Rails)
 
@@ -312,7 +315,10 @@ end
 ```
 
 Viene inviato un `slow_method` solo se la durata supera `slow_method_threshold_ms`. **Gli argomenti
-del metodo non vengono mai inviati** (solo label, durata, file:riga).
+del metodo non vengono inviati** (solo label, durata, file:riga) salvo `capture_method_arguments = true`:
+in quel caso partono con `inspect` troncato, redatti per chiave sensibile (kwargs), credenziali
+`Bearer`/`Basic`/`Token` e `scrub_message_patterns`. Tutto il resto arriva in chiaro: accendilo solo
+su metodi che non ricevono dati personali.
 
 ## Performance issues (opt-in)
 
@@ -395,6 +401,40 @@ ActiveJob dentro Sidekiq è osservato una sola volta quando il subscriber Active
 Sampling, disabilitazione o perdita del transport impediscono di considerare questi log un censimento.
 Il raggruppamento backend v1 separa framework, nome, coda e misura; i gruppi legacy restano intatti.
 
+## Open Dashboard (opt-in)
+
+Il servizio mostra i suoi numeri (utenti, abbonamenti, incassi…) a chi ha la chiave, su
+`GET /open-dashboard`. Lo standard completo: contratto `contracts/open-dashboard/v1`.
+
+```ruby
+# config/initializers/open_dashboard.rb
+CloseYourIt::OpenDashboard.configure do |od|
+  od.token  = ENV["OPEN_DASHBOARD_TOKEN"] # without it the route does not exist
+  od.name   = "scontino"
+  od.app    = "scontino-rails"
+  od.url    = "https://scontino.it"
+  od.locale = "it"
+
+  od.metric "users.registered", label: "Utenti registrati", group: "Utenti", type: :count do |since|
+    { value: User.count, previous: User.where(created_at: ...since).count }
+  end
+
+  od.metric "revenue.mrr", label: "Incasso mensile ricorrente", group: "Incassi",
+            type: :money, currency: "EUR" do
+    Subscription.active.sum(:amount_cents)
+  end
+end
+```
+
+- `since` è l'inizio del periodo di confronto (`period:`, default `"30d"`; anche `1d`, `7d`, `90d`, `365d`).
+- Il blocco restituisce un numero, oppure `{ value:, previous: }`.
+- Tipi: `count` e `money` (interi; `money` in centesimi con `currency`), `percent` (0–100), `duration` (secondi).
+- `better: :down` per i numeri che vanno bene quando scendono.
+- Una metrica che solleva arriva come «non disponibile» e l'errore finisce in CloseYourIt; le altre restano.
+- I blocchi girano a ogni richiesta e chi legge aspetta al massimo 10 secondi: i numeri lenti vanno precalcolati.
+- Una dichiarazione sbagliata (chiave doppia, tipo sconosciuto, `money` senza valuta) blocca l'avvio.
+- Solo totali: mai dati di singole persone.
+
 ## Privacy & PII
 
 Privacy-by-default (`send_pii = false`). In sintesi:
@@ -406,8 +446,10 @@ Privacy-by-default (`send_pii = false`). In sintesi:
   (`Authorization: Bearer …`, `Basic …`, `Token …`) sono redatte **di serie**, senza configurazione:
   chiave e schema restano leggibili, sparisce il valore → `Authorization: Bearer [FILTERED]`. Il resto
   è redigibile con `scrub_message_patterns` / `before_send`.
-- **Mai inviati**: variabili locali dei frame, argomenti dei metodi, IP/cookie/Authorization, token (che
-  viaggia solo nell'header su HTTPS).
+- **Solo con `send_pii`**: query string, IP, email/username dell'utente e parametri del body
+  (`capture_request_body`). Con la privacy spenta non partono, qualunque sia il resto della configurazione.
+- **Mai inviati**: variabili locali dei frame, cookie/Authorization, token (che viaggia solo nell'header
+  su HTTPS). Gli argomenti dei metodi solo con `capture_method_arguments` (opt-in, vedi sopra).
 
 > Rischio residuo: `exception.value` e i nomi tabella/colonna nello SQL possono contenere dati di
 > dominio. Usa `before_send`/`scrub_message_patterns` per azzerarli. Dettaglio in [`PDR.md` §9](PDR.md).

data/lib/closeyourit/configuration.rb

@@ -94,7 +94,8 @@ module CloseYourIt
 
       # Request body params in the event (`request.data`), extracted LAZILY only when the error
       # happens, sanitized and scrubbed (denylist + filter_parameters). The backend scrubs again
-      # defensively. Uploads → placeholder, 64 KB cap.
+      # defensively. Uploads → placeholder, 64 KB cap. Gated by send_pii: with it OFF the body
+      # is never sent, whatever this flag says (CYRB-28).
       @capture_request_body = true
 
       # Breadcrumbs: history (obfuscated queries, custom events) attached to the error.
@@ -200,6 +201,13 @@ module CloseYourIt
       @filter_parameters = Array(list)
     end
 
+    # Adds the host app's `Rails.application.config.filter_parameters` (strings/symbols/regexps) to the
+    # gem list, without duplicates. Rails filter procs are dropped: they mutate values in place, while
+    # the Scrubber matches keys only (CYRB-28).
+    def merge_filter_parameters(list)
+      @filter_parameters |= Array(list).reject { |item| item.respond_to?(:call) }
+    end
+
     # Destinations allowed to receive the W3C trace headers. String = exact host (case-insensitive
     # match), Regexp = pattern (for subdomains/host families). Empty list = none.
     def trace_propagation_allowlist=(list)

data/lib/closeyourit/events/slow_method_event.rb

@@ -42,7 +42,9 @@ module CloseYourIt
     private
 
     # Arguments — ONLY with capture_method_arguments (opt-in). Positional by index; kwargs by name with
-    # sensitive key scrubbing (denylist password/token/…). Value = truncated inspect (JSON-safe).
+    # sensitive key scrubbing (denylist password/token/…). Value = truncated inspect (JSON-safe),
+    # passed through the message scrubber (auth schemes + scrub_message_patterns) like exception
+    # messages, so a token inside a positional argument never leaves the app (CYRB-28).
     def arguments
       return nil unless @configuration.capture_method_arguments
 
@@ -54,7 +56,7 @@ module CloseYourIt
     end
 
     def safe_value(value)
-      inspected = value.inspect.to_s
+      inspected = @scrubber.scrub_message(value.inspect.to_s)
       inspected.length > 120 ? "#{inspected[0, 117]}…" : inspected
     end
   end

data/lib/closeyourit/open_dashboard/metric.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module OpenDashboard
+    # Raised at boot when the service declares a metric the standard does not allow.
+    class ConfigurationError < StandardError; end
+
+    # One metric of the Open Dashboard standard. Rules are checked when the service boots, so a bad
+    # declaration fails the deploy instead of producing an invalid response in production.
+    class Metric
+      TYPES = %w[count money percent duration].freeze
+      INTEGER_TYPES = %w[count money].freeze
+      PERIODS = { "1d" => 1, "7d" => 7, "30d" => 30, "90d" => 90, "365d" => 365 }.freeze
+      BETTER = %w[up down].freeze
+      KEY_FORMAT = /\A[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+\z/
+      CURRENCY_FORMAT = /\A[A-Z]{3}\z/
+      UNAVAILABLE = "unavailable"
+      SECONDS_PER_DAY = 86_400
+
+      attr_reader :key
+
+      def initialize(key, label:, group:, type:, currency: nil, period: "30d", better: nil, &block)
+        @key = key.to_s
+        @label = label.to_s
+        @group = group.to_s
+        @type = type.to_s
+        @currency = currency
+        @period = period.to_s
+        @better = better&.to_s
+        @block = block
+        validate!
+      end
+
+      # The block gets the start of the comparison period. A failure never breaks the other metrics:
+      # it is reported to CloseYourIt and the metric goes out as unavailable.
+      def to_h(now)
+        since = now - (PERIODS.fetch(@period) * SECONDS_PER_DAY)
+        identity.merge(values(@block.call(since)))
+      rescue StandardError => e
+        CloseYourIt.capture_exception(e, handled: true)
+        identity.merge(value: nil, error: UNAVAILABLE)
+      end
+
+      private
+
+      def identity
+        { key: @key, label: @label, group: @group, type: @type, currency: @currency, better: @better }.compact
+      end
+
+      def values(result)
+        return { value: number(result) } unless result.is_a?(Hash)
+
+        out = { value: number(result.fetch(:value)) }
+        out.merge!(previous: number(result[:previous]), period: @period) unless result[:previous].nil?
+        out
+      end
+
+      # Returns the value to emit: an Integer for count/money, a Float for percent/duration.
+      def number(value)
+        reject("value must be numeric") unless value.is_a?(Numeric)
+        reject("value must be finite") unless !value.respond_to?(:finite?) || value.finite?
+
+        normalised = INTEGER_TYPES.include?(@type) ? whole(value) : Float(value)
+        check_range(normalised)
+        normalised
+      end
+
+      def whole(value)
+        reject("#{@type} must be an integer") unless value == value.to_i
+
+        value.to_i
+      end
+
+      def check_range(value)
+        reject("count must not be negative") if @type == "count" && value.negative?
+        reject("percent must be between 0 and 100") if @type == "percent" && !value.between?(0, 100)
+        reject("duration must not be negative") if @type == "duration" && value.negative?
+      end
+
+      def reject(message)
+        raise TypeError, "open_dashboard metric #{@key}: #{message}"
+      end
+
+      def validate!
+        fail_with("key must be lowercase and dotted, e.g. users.registered") unless KEY_FORMAT.match?(@key)
+        fail_with("label is blank") if @label.strip.empty?
+        fail_with("group is blank") if @group.strip.empty?
+        fail_with("type must be one of #{TYPES.join(', ')}") unless TYPES.include?(@type)
+        validate_currency!
+        fail_with("period must be one of #{PERIODS.keys.join(', ')}") unless PERIODS.key?(@period)
+        fail_with("better must be up or down") if @better && !BETTER.include?(@better)
+        fail_with("a block computing the value is required") unless @block
+      end
+
+      def validate_currency!
+        if @type == "money"
+          fail_with("money needs an ISO 4217 currency, e.g. EUR") unless CURRENCY_FORMAT.match?(@currency.to_s)
+        elsif @currency
+          fail_with("currency is allowed only on money")
+        end
+      end
+
+      def fail_with(message)
+        raise ConfigurationError, "open_dashboard metric #{@key}: #{message}"
+      end
+    end
+  end
+end

data/lib/closeyourit/open_dashboard/middleware.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "openssl"
+
+module CloseYourIt
+  module OpenDashboard
+    # Pure Rack: answers GET /open-dashboard and passes everything else to the app. Without a token
+    # the request also goes to the app, so the route simply does not exist (404 from the app).
+    class Middleware
+      JSON_HEADERS = { "content-type" => "application/json", "cache-control" => "no-store" }.freeze
+      BEARER = "Bearer "
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        settings = OpenDashboard.settings
+        return @app.call(env) unless dashboard_request?(env) && settings&.enabled?
+        return [ 401, { "cache-control" => "no-store" }, [] ] unless authorized?(env["HTTP_AUTHORIZATION"], settings.token)
+
+        [ 200, JSON_HEADERS.dup, [ JSON.generate(Report.new(settings).to_h) ] ]
+      end
+
+      private
+
+      def dashboard_request?(env)
+        env["REQUEST_METHOD"] == "GET" && env["PATH_INFO"] == PATH
+      end
+
+      # Hashing both sides gives equal lengths, so the comparison time does not leak the token length.
+      def authorized?(header, token)
+        header = header.to_s
+        return false unless header.start_with?(BEARER)
+
+        OpenSSL.fixed_length_secure_compare(
+          Digest::SHA256.digest(header.delete_prefix(BEARER)),
+          Digest::SHA256.digest(token.to_s)
+        )
+      end
+    end
+  end
+end

data/lib/closeyourit/open_dashboard/report.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "time"
+
+module CloseYourIt
+  module OpenDashboard
+    # Builds the response body. Service identity comes from the same ENV as GET /version, so the
+    # dashboard and the deploy smoke test always agree on which build is live.
+    class Report
+      UNKNOWN = "unknown"
+
+      def initialize(settings, now: Time.now.utc)
+        @settings = settings
+        @now = now
+      end
+
+      def to_h
+        {
+          open_dashboard: SPEC_VERSION,
+          service: service,
+          locale: @settings.locale,
+          generated_at: @now.getutc.iso8601,
+          metrics: @settings.metrics.map { |metric| metric.to_h(@now) }
+        }
+      end
+
+      private
+
+      def service
+        {
+          name: @settings.name,
+          app: @settings.app,
+          version: present(ENV["APP_GIT_TAG"]) || UNKNOWN,
+          sha: present(ENV["APP_GIT_SHA"])&.slice(0, 7) || UNKNOWN,
+          environment: CloseYourIt.configuration.environment.to_s,
+          url: present(@settings.url)
+        }.compact
+      end
+
+      def present(value)
+        value.to_s.strip.empty? ? nil : value.to_s
+      end
+    end
+  end
+end

data/lib/closeyourit/open_dashboard/settings.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module OpenDashboard
+    # What the service declares in config/initializers/open_dashboard.rb.
+    class Settings
+      LOCALE_FORMAT = /\A[a-z]{2}(-[A-Z]{2})?\z/
+
+      attr_accessor :token, :name, :app, :url, :locale
+      attr_reader :metrics
+
+      def initialize
+        @metrics = []
+      end
+
+      def metric(key, **options, &block)
+        if @metrics.any? { |existing| existing.key == key.to_s }
+          raise ConfigurationError, "open_dashboard metric #{key}: duplicated key"
+        end
+
+        @metrics << Metric.new(key, **options, &block)
+      end
+
+      # No token means the feature is off: the route does not exist.
+      def enabled? = !token.to_s.strip.empty?
+
+      def validate!
+        %i[name app].each do |field|
+          raise ConfigurationError, "open_dashboard: #{field} is required" if public_send(field).to_s.strip.empty?
+        end
+        raise ConfigurationError, "open_dashboard: locale must look like it or en-US" unless LOCALE_FORMAT.match?(locale.to_s)
+        raise ConfigurationError, "open_dashboard: at most #{MAX_METRICS} metrics" if @metrics.size > MAX_METRICS
+      end
+    end
+  end
+end

data/lib/closeyourit/open_dashboard.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  # Open Dashboard standard: GET /open-dashboard returns who the service is and its business
+  # numbers, behind a per-service token. Contract: contracts/open-dashboard/v1.
+  module OpenDashboard
+    SPEC_VERSION = "1.0"
+    PATH = "/open-dashboard"
+    MAX_METRICS = 50
+
+    class << self
+      # Kept separate from CloseYourIt.init: init rebuilds its configuration on every call, and the
+      # dashboard declaration must not disappear when telemetry is reconfigured.
+      def configure
+        candidate = Settings.new
+        yield candidate
+        candidate.validate!
+        @settings = candidate
+      end
+
+      attr_reader :settings
+
+      def reset!
+        @settings = nil
+      end
+    end
+  end
+end
+
+require_relative "open_dashboard/metric"
+require_relative "open_dashboard/settings"
+require_relative "open_dashboard/report"
+require_relative "open_dashboard/middleware"

data/lib/closeyourit/rails/railtie.rb

@@ -28,6 +28,16 @@ module CloseYourIt
         )
       end
 
+      # Open Dashboard (GET /open-dashboard). Inside CaptureExceptions, so a crash while building the
+      # report is reported like any other request error. Inert until the app calls
+      # CloseYourIt::OpenDashboard.configure with a token.
+      initializer "closeyourit.open_dashboard" do |app|
+        app.config.middleware.insert_after(
+          CloseYourIt::Rails::CaptureExceptions,
+          CloseYourIt::OpenDashboard::Middleware
+        )
+      end
+
       initializer "closeyourit.subscribe_slow_queries" do
         subscriber = CloseYourIt::Subscribers::SlowQuery.new
 
@@ -100,6 +110,13 @@ module CloseYourIt
         end
       end
 
+      # Keys the app declared sensitive via config.filter_parameters are scrubbed by the gem too.
+      # `after: :load_config_initializers`: CloseYourIt.init (config/initializers/closeyourit.rb)
+      # replaces the configuration, so an earlier merge would be lost (CYRB-28).
+      initializer "closeyourit.merge_rails_filter_parameters", after: :load_config_initializers do |app|
+        CloseYourIt.configuration.merge_filter_parameters(app.config.filter_parameters)
+      end
+
       # Captures Sidekiq job errors + measures duration/wait via server middleware (only when Sidekiq
       # is present). The middleware is effectively a no-op when monitor_jobs is OFF (the decision
       # lives in JobPerformance#record).

data/lib/closeyourit/scope.rb

@@ -139,8 +139,10 @@ module CloseYourIt
       data ? @request.merge("data" => data) : @request
     end
 
+    # Body params are user input (PII): sent only with send_pii AND capture_request_body (CYRB-28).
     def request_body_data
-      return nil unless CloseYourIt.configuration.capture_request_body
+      config = CloseYourIt.configuration
+      return nil unless config.send_pii && config.capture_request_body
       return nil if @rack_env.nil?
 
       Rails::RequestBody.extract(@rack_env)

data/lib/closeyourit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloseYourIt
-  VERSION = "0.11.0"
+  VERSION = "0.13.0"
 end

data/lib/closeyourit-ruby.rb

@@ -39,6 +39,7 @@ require_relative "closeyourit/rails/active_job_extension"
 require_relative "closeyourit/rails/error_subscriber"
 require_relative "closeyourit/sidekiq/error_handler"
 require_relative "closeyourit/sidekiq/job_metrics_middleware"
+require_relative "closeyourit/open_dashboard"
 
 # CloseYourIt — telemetry client (errors + slow query/method statistics)
 # that sends events to the CloseYourIt ingest endpoint.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closeyourit-ruby
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Alessio Bussolari
@@ -67,6 +67,11 @@ files:
 - lib/closeyourit/log_buffer.rb
 - lib/closeyourit/log_device.rb
 - lib/closeyourit/monitor.rb
+- lib/closeyourit/open_dashboard.rb
+- lib/closeyourit/open_dashboard/metric.rb
+- lib/closeyourit/open_dashboard/middleware.rb
+- lib/closeyourit/open_dashboard/report.rb
+- lib/closeyourit/open_dashboard/settings.rb
 - lib/closeyourit/performance/request_profile.rb
 - lib/closeyourit/performance/rollup.rb
 - lib/closeyourit/rails/active_job_extension.rb
@@ -90,12 +95,12 @@ files:
 - lib/closeyourit/transport.rb
 - lib/closeyourit/usage_registry.rb
 - lib/closeyourit/version.rb
-homepage: https://github.com/bussolabs/closeyourit-ruby
+homepage: https://github.com/bussolabs/closeyourit-ruby-community
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/bussolabs/closeyourit-ruby
-  source_code_uri: https://github.com/bussolabs/closeyourit-ruby
+  homepage_uri: https://github.com/bussolabs/closeyourit-ruby-community
+  source_code_uri: https://github.com/bussolabs/closeyourit-ruby-community
 rdoc_options: []
 require_paths:
 - lib