prometheus_exporter 2.1.0 → 2.2.0

data/lib/prometheus_exporter/server/active_record_collector.rb

@@ -10,15 +10,15 @@ module PrometheusExporter::Server
       dead: "Dead connections in pool",
       idle: "Idle connections in pool",
       waiting: "Connection requests waiting",
-      size: "Maximum allowed connection pool size"
+      size: "Maximum allowed connection pool size",
     }
 
     def initialize
       @active_record_metrics = MetricsContainer.new(ttl: MAX_METRIC_AGE)
-      @active_record_metrics.filter = -> (new_metric, old_metric) do
+      @active_record_metrics.filter = ->(new_metric, old_metric) do
         new_metric["pid"] == old_metric["pid"] &&
-        new_metric["hostname"] == old_metric["hostname"] &&
-        new_metric["metric_labels"]["pool_name"] == old_metric["metric_labels"]["pool_name"]
+          new_metric["hostname"] == old_metric["hostname"] &&
+          new_metric["metric_labels"]["pool_name"] == old_metric["metric_labels"]["pool_name"]
       end
     end
 
@@ -32,13 +32,18 @@ module PrometheusExporter::Server
       metrics = {}
 
       @active_record_metrics.map do |m|
-        metric_key = (m["metric_labels"] || {}).merge("pid" => m["pid"], "hostname" => m["hostname"])
+        metric_key =
+          (m["metric_labels"] || {}).merge("pid" => m["pid"], "hostname" => m["hostname"])
         metric_key.merge!(m["custom_labels"]) if m["custom_labels"]
 
         ACTIVE_RECORD_GAUGES.map do |k, help|
           k = k.to_s
           if v = m[k]
-            g = metrics[k] ||= PrometheusExporter::Metric::Gauge.new("active_record_connection_pool_#{k}", help)
+            g =
+              metrics[k] ||= PrometheusExporter::Metric::Gauge.new(
+                "active_record_connection_pool_#{k}",
+                help,
+              )
             g.observe(v, metric_key)
           end
         end

data/lib/prometheus_exporter/server/collector.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 module PrometheusExporter::Server
-
   class Collector < CollectorBase
-
     def initialize(json_serializer: nil)
       @process_metrics = []
       @metrics = {}
@@ -40,19 +38,15 @@ module PrometheusExporter::Server
           collector.collect(obj)
         else
           metric = @metrics[obj["name"]]
-          if !metric
-            metric = register_metric_unsafe(obj)
-          end
+          metric = register_metric_unsafe(obj) if !metric
 
           keys = obj["keys"] || {}
-          if obj["custom_labels"]
-            keys = obj["custom_labels"].merge(keys)
-          end
+          keys = obj["custom_labels"].merge(keys) if obj["custom_labels"]
 
           case obj["prometheus_exporter_action"]
-          when 'increment'
+          when "increment"
             metric.increment(keys, obj["value"])
-          when 'decrement'
+          when "decrement"
             metric.decrement(keys, obj["value"])
           else
             metric.observe(obj["value"], keys)
@@ -63,15 +57,14 @@ module PrometheusExporter::Server
 
     def prometheus_metrics_text
       @mutex.synchronize do
-        (@metrics.values + @collectors.values.map(&:metrics).flatten)
-          .map(&:to_prometheus_text).join("\n")
+        (@metrics.values + @collectors.values.map(&:metrics).flatten).map(
+          &:to_prometheus_text
+        ).join("\n")
       end
     end
 
     def register_metric(metric)
-      @mutex.synchronize do
-        @metrics[metric.name] = metric
-      end
+      @mutex.synchronize { @metrics[metric.name] = metric }
     end
 
     protected
@@ -101,7 +94,10 @@ module PrometheusExporter::Server
     end
 
     def symbolize_keys(hash)
-      hash.inject({}) { |memo, k| memo[k.first.to_sym] = k.last; memo }
+      hash.inject({}) do |memo, k|
+        memo[k.first.to_sym] = k.last
+        memo
+      end
     end
   end
 end

data/lib/prometheus_exporter/server/collector_base.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 module PrometheusExporter::Server
-
   # minimal interface to implement a customer collector
   class CollectorBase
-
     # called each time a string is delivered from the web
     def process(str)
     end

data/lib/prometheus_exporter/server/delayed_job_collector.rb

@@ -20,19 +20,31 @@ module PrometheusExporter::Server
     end
 
     def collect(obj)
-      custom_labels = obj['custom_labels'] || {}
-      gauge_labels = { queue_name: obj['queue_name'] }.merge(custom_labels)
-      counter_labels = gauge_labels.merge(job_name: obj['name'])
+      custom_labels = obj["custom_labels"] || {}
+      gauge_labels = { queue_name: obj["queue_name"] }.merge(custom_labels)
+      counter_labels = gauge_labels.merge(job_name: obj["name"])
 
       ensure_delayed_job_metrics
       @delayed_job_duration_seconds.observe(obj["duration"], counter_labels)
       @delayed_job_latency_seconds_total.observe(obj["latency"], counter_labels)
       @delayed_jobs_total.observe(1, counter_labels)
       @delayed_failed_jobs_total.observe(1, counter_labels) if !obj["success"]
-      @delayed_jobs_max_attempts_reached_total.observe(1, counter_labels) if obj["attempts"] >= obj["max_attempts"]
+      if obj["attempts"] >= obj["max_attempts"]
+        @delayed_jobs_max_attempts_reached_total.observe(1, counter_labels)
+      end
       @delayed_job_duration_seconds_summary.observe(obj["duration"], counter_labels)
-      @delayed_job_duration_seconds_summary.observe(obj["duration"], counter_labels.merge(status: "success")) if obj["success"]
-      @delayed_job_duration_seconds_summary.observe(obj["duration"], counter_labels.merge(status: "failed"))  if !obj["success"]
+      if obj["success"]
+        @delayed_job_duration_seconds_summary.observe(
+          obj["duration"],
+          counter_labels.merge(status: "success"),
+        )
+      end
+      if !obj["success"]
+        @delayed_job_duration_seconds_summary.observe(
+          obj["duration"],
+          counter_labels.merge(status: "failed"),
+        )
+      end
       @delayed_job_attempts_summary.observe(obj["attempts"], counter_labels) if obj["success"]
       @delayed_jobs_enqueued.observe(obj["enqueued"], gauge_labels)
       @delayed_jobs_pending.observe(obj["pending"], gauge_labels)
@@ -40,9 +52,17 @@ module PrometheusExporter::Server
 
     def metrics
       if @delayed_jobs_total
-        [@delayed_job_duration_seconds, @delayed_job_latency_seconds_total, @delayed_jobs_total, @delayed_failed_jobs_total,
-         @delayed_jobs_max_attempts_reached_total, @delayed_job_duration_seconds_summary, @delayed_job_attempts_summary,
-         @delayed_jobs_enqueued, @delayed_jobs_pending]
+        [
+          @delayed_job_duration_seconds,
+          @delayed_job_latency_seconds_total,
+          @delayed_jobs_total,
+          @delayed_failed_jobs_total,
+          @delayed_jobs_max_attempts_reached_total,
+          @delayed_job_duration_seconds_summary,
+          @delayed_job_attempts_summary,
+          @delayed_jobs_enqueued,
+          @delayed_jobs_pending,
+        ]
       else
         []
       end
@@ -52,42 +72,59 @@ module PrometheusExporter::Server
 
     def ensure_delayed_job_metrics
       if !@delayed_jobs_total
-
         @delayed_job_duration_seconds =
-        PrometheusExporter::Metric::Counter.new(
-          "delayed_job_duration_seconds", "Total time spent in delayed jobs.")
+          PrometheusExporter::Metric::Counter.new(
+            "delayed_job_duration_seconds",
+            "Total time spent in delayed jobs.",
+          )
 
         @delayed_job_latency_seconds_total =
-        PrometheusExporter::Metric::Counter.new(
-          "delayed_job_latency_seconds_total", "Total delayed jobs latency.")
+          PrometheusExporter::Metric::Counter.new(
+            "delayed_job_latency_seconds_total",
+            "Total delayed jobs latency.",
+          )
 
         @delayed_jobs_total =
-        PrometheusExporter::Metric::Counter.new(
-          "delayed_jobs_total", "Total number of delayed jobs executed.")
+          PrometheusExporter::Metric::Counter.new(
+            "delayed_jobs_total",
+            "Total number of delayed jobs executed.",
+          )
 
         @delayed_jobs_enqueued =
-        PrometheusExporter::Metric::Gauge.new(
-          "delayed_jobs_enqueued", "Number of enqueued delayed jobs.")
+          PrometheusExporter::Metric::Gauge.new(
+            "delayed_jobs_enqueued",
+            "Number of enqueued delayed jobs.",
+          )
 
         @delayed_jobs_pending =
-        PrometheusExporter::Metric::Gauge.new(
-          "delayed_jobs_pending", "Number of pending delayed jobs.")
+          PrometheusExporter::Metric::Gauge.new(
+            "delayed_jobs_pending",
+            "Number of pending delayed jobs.",
+          )
 
         @delayed_failed_jobs_total =
-        PrometheusExporter::Metric::Counter.new(
-          "delayed_failed_jobs_total", "Total number failed delayed jobs executed.")
+          PrometheusExporter::Metric::Counter.new(
+            "delayed_failed_jobs_total",
+            "Total number failed delayed jobs executed.",
+          )
 
         @delayed_jobs_max_attempts_reached_total =
-            PrometheusExporter::Metric::Counter.new(
-                "delayed_jobs_max_attempts_reached_total", "Total number of delayed jobs that reached max attempts.")
+          PrometheusExporter::Metric::Counter.new(
+            "delayed_jobs_max_attempts_reached_total",
+            "Total number of delayed jobs that reached max attempts.",
+          )
 
         @delayed_job_duration_seconds_summary =
-            PrometheusExporter::Metric::Base.default_aggregation.new("delayed_job_duration_seconds_summary",
-                                                                     "Summary of the time it takes jobs to execute.")
+          PrometheusExporter::Metric::Base.default_aggregation.new(
+            "delayed_job_duration_seconds_summary",
+            "Summary of the time it takes jobs to execute.",
+          )
 
         @delayed_job_attempts_summary =
-            PrometheusExporter::Metric::Base.default_aggregation.new("delayed_job_attempts_summary",
-                                                                     "Summary of the amount of attempts it takes delayed jobs to succeed.")
+          PrometheusExporter::Metric::Base.default_aggregation.new(
+            "delayed_job_attempts_summary",
+            "Summary of the amount of attempts it takes delayed jobs to succeed.",
+          )
       end
     end
   end

data/lib/prometheus_exporter/server/good_job_collector.rb

@@ -10,7 +10,7 @@ module PrometheusExporter::Server
       running: "Total number of running GoodJob jobs.",
       finished: "Total number of finished GoodJob jobs.",
       succeeded: "Total number of succeeded GoodJob jobs.",
-      discarded: "Total number of discarded GoodJob jobs."
+      discarded: "Total number of discarded GoodJob jobs.",
     }
 
     def initialize

data/lib/prometheus_exporter/server/hutch_collector.rb

@@ -14,8 +14,8 @@ module PrometheusExporter::Server
     end
 
     def collect(obj)
-      default_labels = { job_name: obj['name'] }
-      custom_labels = obj['custom_labels']
+      default_labels = { job_name: obj["name"] }
+      custom_labels = obj["custom_labels"]
       labels = custom_labels.nil? ? default_labels : default_labels.merge(custom_labels)
 
       ensure_hutch_metrics
@@ -36,15 +36,23 @@ module PrometheusExporter::Server
 
     def ensure_hutch_metrics
       if !@hutch_jobs_total
-
-        @hutch_job_duration_seconds = PrometheusExporter::Metric::Counter.new(
-          "hutch_job_duration_seconds", "Total time spent in hutch jobs.")
-
-        @hutch_jobs_total = PrometheusExporter::Metric::Counter.new(
-          "hutch_jobs_total", "Total number of hutch jobs executed.")
-
-        @hutch_failed_jobs_total = PrometheusExporter::Metric::Counter.new(
-          "hutch_failed_jobs_total", "Total number failed hutch jobs executed.")
+        @hutch_job_duration_seconds =
+          PrometheusExporter::Metric::Counter.new(
+            "hutch_job_duration_seconds",
+            "Total time spent in hutch jobs.",
+          )
+
+        @hutch_jobs_total =
+          PrometheusExporter::Metric::Counter.new(
+            "hutch_jobs_total",
+            "Total number of hutch jobs executed.",
+          )
+
+        @hutch_failed_jobs_total =
+          PrometheusExporter::Metric::Counter.new(
+            "hutch_failed_jobs_total",
+            "Total number failed hutch jobs executed.",
+          )
       end
     end
   end

data/lib/prometheus_exporter/server/metrics_container.rb

@@ -9,10 +9,10 @@ module PrometheusExporter::Server
     attr_accessor :filter
 
     def initialize(ttl: METRIC_MAX_AGE, expire_attr: METRIC_EXPIRE_ATTR, filter: nil)
-      @data          = []
-      @ttl           = ttl
-      @expire_attr   = expire_attr
-      @filter        = filter
+      @data = []
+      @ttl = ttl
+      @expire_attr = expire_attr
+      @filter = filter
     end
 
     def <<(obj)

data/lib/prometheus_exporter/server/process_collector.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module PrometheusExporter::Server
-
   class ProcessCollector < TypeCollector
     MAX_METRIC_AGE = 60
 
@@ -13,6 +12,10 @@ module PrometheusExporter::Server
       v8_physical_size: "Physical size consumed by V8 heaps.",
       v8_heap_count: "Number of V8 contexts running.",
       rss: "Total RSS used by process.",
+      malloc_increase_bytes_limit:
+        "Limit before Ruby triggers a GC against current objects (bytes).",
+      oldmalloc_increase_bytes_limit:
+        "Limit before Ruby triggers a major GC against old objects (bytes).",
     }
 
     PROCESS_COUNTERS = {
@@ -23,7 +26,7 @@ module PrometheusExporter::Server
 
     def initialize
       @process_metrics = MetricsContainer.new(ttl: MAX_METRIC_AGE)
-      @process_metrics.filter = -> (new_metric, old_metric) do
+      @process_metrics.filter = ->(new_metric, old_metric) do
         new_metric["pid"] == old_metric["pid"] && new_metric["hostname"] == old_metric["hostname"]
       end
     end
@@ -38,7 +41,8 @@ module PrometheusExporter::Server
       metrics = {}
 
       @process_metrics.map do |m|
-        metric_key = (m["metric_labels"] || {}).merge("pid" => m["pid"], "hostname" => m["hostname"])
+        metric_key =
+          (m["metric_labels"] || {}).merge("pid" => m["pid"], "hostname" => m["hostname"])
         metric_key.merge!(m["custom_labels"]) if m["custom_labels"]
 
         PROCESS_GAUGES.map do |k, help|

data/lib/prometheus_exporter/server/puma_collector.rb

@@ -15,7 +15,7 @@ module PrometheusExporter::Server
 
     def initialize
       @puma_metrics = MetricsContainer.new(ttl: MAX_PUMA_METRIC_AGE)
-      @puma_metrics.filter = -> (new_metric, old_metric) do
+      @puma_metrics.filter = ->(new_metric, old_metric) do
         new_metric["pid"] == old_metric["pid"] && new_metric["hostname"] == old_metric["hostname"]
       end
     end
@@ -31,15 +31,9 @@ module PrometheusExporter::Server
 
       @puma_metrics.map do |m|
         labels = {}
-        if m["phase"]
-          labels.merge!(phase: m["phase"])
-        end
-        if m["custom_labels"]
-          labels.merge!(m["custom_labels"])
-        end
-        if m["metric_labels"]
-          labels.merge!(m["metric_labels"])
-        end
+        labels.merge!(phase: m["phase"]) if m["phase"]
+        labels.merge!(m["custom_labels"]) if m["custom_labels"]
+        labels.merge!(m["metric_labels"]) if m["metric_labels"]
 
         PUMA_GAUGES.map do |k, help|
           k = k.to_s

data/lib/prometheus_exporter/server/resque_collector.rb

@@ -9,7 +9,7 @@ module PrometheusExporter::Server
       pending_jobs: "Total number of pending Resque jobs.",
       queues: "Total number of Resque queues.",
       workers: "Total number of Resque workers running.",
-      working: "Total number of Resque workers working."
+      working: "Total number of Resque workers working.",
     }
 
     def initialize

data/lib/prometheus_exporter/server/runner.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../client'
+require_relative "../client"
 
 module PrometheusExporter::Server
-  class RunnerException < StandardError; end
-  class WrongInheritance < RunnerException; end
+  class RunnerException < StandardError
+  end
+
+  class WrongInheritance < RunnerException
+  end
 
   class Runner
     def initialize(options = {})
@@ -18,9 +21,7 @@ module PrometheusExporter::Server
       @realm = nil
       @histogram = nil
 
-      options.each do |k, v|
-        send("#{k}=", v) if self.class.method_defined?("#{k}=")
-      end
+      options.each { |k, v| send("#{k}=", v) if self.class.method_defined?("#{k}=") }
     end
 
     def start
@@ -34,27 +35,47 @@ module PrometheusExporter::Server
       register_type_collectors
 
       unless collector.is_a?(PrometheusExporter::Server::CollectorBase)
-        raise WrongInheritance, 'Collector class must be inherited from PrometheusExporter::Server::CollectorBase'
+        raise WrongInheritance,
+              "Collector class must be inherited from PrometheusExporter::Server::CollectorBase"
       end
 
       if unicorn_listen_address && unicorn_pid_file
-
-        require_relative '../instrumentation'
+        require_relative "../instrumentation"
 
         local_client = PrometheusExporter::LocalClient.new(collector: collector)
         PrometheusExporter::Instrumentation::Unicorn.start(
           pid_file: unicorn_pid_file,
           listener_address: unicorn_listen_address,
-          client: local_client
+          client: local_client,
         )
       end
 
-      server = server_class.new(port: port, bind: bind, collector: collector, timeout: timeout, verbose: verbose, auth: auth, realm: realm)
+      server =
+        server_class.new(
+          port: port,
+          bind: bind,
+          collector: collector,
+          timeout: timeout,
+          verbose: verbose,
+          auth: auth,
+          realm: realm,
+        )
       server.start
     end
 
     attr_accessor :unicorn_listen_address, :unicorn_pid_file
-    attr_writer :prefix, :port, :bind, :collector_class, :type_collectors, :timeout, :verbose, :server_class, :label, :auth, :realm, :histogram
+    attr_writer :prefix,
+                :port,
+                :bind,
+                :collector_class,
+                :type_collectors,
+                :timeout,
+                :verbose,
+                :server_class,
+                :label,
+                :auth,
+                :realm,
+                :histogram
 
     def auth
       @auth || nil
@@ -89,7 +110,7 @@ module PrometheusExporter::Server
     end
 
     def verbose
-      return @verbose if defined? @verbose
+      return @verbose if defined?(@verbose)
       false
     end
 

data/lib/prometheus_exporter/server/shoryuken_collector.rb

@@ -2,7 +2,6 @@
 
 module PrometheusExporter::Server
   class ShoryukenCollector < TypeCollector
-
     def initialize
       @shoryuken_jobs_total = nil
       @shoryuken_job_duration_seconds = nil
@@ -16,8 +15,8 @@ module PrometheusExporter::Server
     end
 
     def collect(obj)
-      default_labels = { job_name: obj['name'] , queue_name: obj['queue'] }
-      custom_labels = obj['custom_labels']
+      default_labels = { job_name: obj["name"], queue_name: obj["queue"] }
+      custom_labels = obj["custom_labels"]
       labels = custom_labels.nil? ? default_labels : default_labels.merge(custom_labels)
 
       ensure_shoryuken_metrics
@@ -30,10 +29,10 @@ module PrometheusExporter::Server
     def metrics
       if @shoryuken_jobs_total
         [
-            @shoryuken_job_duration_seconds,
-            @shoryuken_jobs_total,
-            @shoryuken_restarted_jobs_total,
-            @shoryuken_failed_jobs_total,
+          @shoryuken_job_duration_seconds,
+          @shoryuken_jobs_total,
+          @shoryuken_restarted_jobs_total,
+          @shoryuken_failed_jobs_total,
         ]
       else
         []
@@ -44,23 +43,29 @@ module PrometheusExporter::Server
 
     def ensure_shoryuken_metrics
       if !@shoryuken_jobs_total
-
         @shoryuken_job_duration_seconds =
-            PrometheusExporter::Metric::Counter.new(
-                "shoryuken_job_duration_seconds", "Total time spent in shoryuken jobs.")
+          PrometheusExporter::Metric::Counter.new(
+            "shoryuken_job_duration_seconds",
+            "Total time spent in shoryuken jobs.",
+          )
 
         @shoryuken_jobs_total =
-            PrometheusExporter::Metric::Counter.new(
-                "shoryuken_jobs_total", "Total number of shoryuken jobs executed.")
+          PrometheusExporter::Metric::Counter.new(
+            "shoryuken_jobs_total",
+            "Total number of shoryuken jobs executed.",
+          )
 
         @shoryuken_restarted_jobs_total =
-            PrometheusExporter::Metric::Counter.new(
-                "shoryuken_restarted_jobs_total", "Total number of shoryuken jobs that we restarted because of a shoryuken shutdown.")
+          PrometheusExporter::Metric::Counter.new(
+            "shoryuken_restarted_jobs_total",
+            "Total number of shoryuken jobs that we restarted because of a shoryuken shutdown.",
+          )
 
         @shoryuken_failed_jobs_total =
-            PrometheusExporter::Metric::Counter.new(
-                "shoryuken_failed_jobs_total", "Total number of failed shoryuken jobs.")
-
+          PrometheusExporter::Metric::Counter.new(
+            "shoryuken_failed_jobs_total",
+            "Total number of failed shoryuken jobs.",
+          )
       end
     end
   end

data/lib/prometheus_exporter/server/sidekiq_collector.rb

@@ -2,7 +2,6 @@
 
 module PrometheusExporter::Server
   class SidekiqCollector < TypeCollector
-
     def initialize
       @sidekiq_jobs_total = nil
       @sidekiq_job_duration_seconds = nil
@@ -17,8 +16,8 @@ module PrometheusExporter::Server
     end
 
     def collect(obj)
-      default_labels = { job_name: obj['name'], queue: obj['queue'] }
-      custom_labels = obj['custom_labels']
+      default_labels = { job_name: obj["name"], queue: obj["queue"] }
+      custom_labels = obj["custom_labels"]
       labels = custom_labels.nil? ? default_labels : default_labels.merge(custom_labels)
 
       ensure_sidekiq_metrics
@@ -50,26 +49,35 @@ module PrometheusExporter::Server
 
     def ensure_sidekiq_metrics
       if !@sidekiq_jobs_total
-
         @sidekiq_job_duration_seconds =
-        PrometheusExporter::Metric::Base.default_aggregation.new(
-          "sidekiq_job_duration_seconds", "Total time spent in sidekiq jobs.")
+          PrometheusExporter::Metric::Base.default_aggregation.new(
+            "sidekiq_job_duration_seconds",
+            "Total time spent in sidekiq jobs.",
+          )
 
         @sidekiq_jobs_total =
-        PrometheusExporter::Metric::Counter.new(
-          "sidekiq_jobs_total", "Total number of sidekiq jobs executed.")
+          PrometheusExporter::Metric::Counter.new(
+            "sidekiq_jobs_total",
+            "Total number of sidekiq jobs executed.",
+          )
 
         @sidekiq_restarted_jobs_total =
-        PrometheusExporter::Metric::Counter.new(
-          "sidekiq_restarted_jobs_total", "Total number of sidekiq jobs that we restarted because of a sidekiq shutdown.")
+          PrometheusExporter::Metric::Counter.new(
+            "sidekiq_restarted_jobs_total",
+            "Total number of sidekiq jobs that we restarted because of a sidekiq shutdown.",
+          )
 
         @sidekiq_failed_jobs_total =
-        PrometheusExporter::Metric::Counter.new(
-          "sidekiq_failed_jobs_total", "Total number of failed sidekiq jobs.")
+          PrometheusExporter::Metric::Counter.new(
+            "sidekiq_failed_jobs_total",
+            "Total number of failed sidekiq jobs.",
+          )
 
         @sidekiq_dead_jobs_total =
-        PrometheusExporter::Metric::Counter.new(
-          "sidekiq_dead_jobs_total", "Total number of dead sidekiq jobs.")
+          PrometheusExporter::Metric::Counter.new(
+            "sidekiq_dead_jobs_total",
+            "Total number of dead sidekiq jobs.",
+          )
       end
     end
   end