inst_statsd 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52813306c6a3409e9abe7f114c58a471afe310eadd722bf555d0bd058144ce06
-  data.tar.gz: a899e4395f5cf3340040e500ad7ccdf4ac3f7c0fbcccbb52bb738f35e9f353a1
+  metadata.gz: d30f765062a97af9d2fb24f537f909d280ff5c4e3f73e88f26a295672beceb70
+  data.tar.gz: ec16ef1cf597f17562545f61919d554eea88cca7c7c41d490018ce554fa052ea
 SHA512:
-  metadata.gz: e81e6b93a69826837fd5d952db4e9d784d3ae9230e72e9a62c6abb21dba6deb248a9baf89690e4d4bad4b0710bfd0dd72d93e5d8463f60c8265dbfbc42ea152c
-  data.tar.gz: 718e935a24b5e899c1bd67ea5669bcb0fada8e78a71c6e2b93b43f57b3744354fe732ebe702f2e06fb28ad8a325dbc3a319d99e58916aef593445a5d172607fb
+  metadata.gz: 7abdd65611b4a20abdbbf84041365269fd78dec587cdaa82a34445ed79f48b884bca0fe36fba5771723b9130354e0eb6e77110686d5418997a2d86fd2036b7ad
+  data.tar.gz: 861b9d44c819dcae0d776c0e180b5b26000023bc8ce2d73a32009ed7533fa6840e00faad63c56be6991004ccc84b3ff9735adbbaa2931e790a7155831e81409b

data/lib/inst_statsd/block_stat.rb

@@ -2,13 +2,9 @@
 
 module InstStatsd
   class BlockStat
+    attr_accessor :stats, :common_key, :short_stat, :tags
 
-    attr_accessor :stats
-    attr_accessor :common_key
-    attr_accessor :short_stat
-    attr_accessor :tags
-
-    def initialize(common_key, statsd=InstStatsd::Statsd, tags: {}, short_stat: nil)
+    def initialize(common_key, statsd = InstStatsd::Statsd, tags: {}, short_stat: nil)
       self.common_key = common_key
       @tags = tags
       @short_stat = short_stat
@@ -27,17 +23,21 @@ module InstStatsd
 
     def exclusive_stats
       return nil unless @exclusives
-      stats.map { |key, value| [key, value - (@exclusives[key] || 0.0)] }.to_h
+
+      stats.to_h { |key, value| [key, value - (@exclusives[key] || 0.0)] }
     end
 
     def report
-      if common_key
-        stats.each do |(key, value)|
-          @statsd.timing("#{common_key}.#{key}", value, tags: @tags, short_stat: "#{@short_stat}.#{key}")
-        end
-        exclusive_stats&.each do |(key, value)|
-          @statsd.timing("#{common_key}.exclusive.#{key}", value, tags: @tags, short_stat: "#{@short_stat}.exclusive.#{key}")
-        end
+      return unless common_key
+
+      stats.each do |(key, value)|
+        @statsd.timing("#{common_key}.#{key}", value, tags: @tags, short_stat: "#{@short_stat}.#{key}")
+      end
+      exclusive_stats&.each do |(key, value)|
+        @statsd.timing("#{common_key}.exclusive.#{key}",
+                       value,
+                       tags: @tags,
+                       short_stat: "#{@short_stat}.exclusive.#{key}")
       end
     end
   end

data/lib/inst_statsd/block_tracking.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require 'benchmark'
+require "benchmark"
 
 module InstStatsd
   class BlockTracking
     class << self
       attr_accessor :logger
 
-      [:mask, :negative_mask].each do |method|
+      %i[mask negative_mask].each do |method|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{method}
-            InstStatsd.settings[:#{method}]
-          end
-
-          def #{method}=(value)
-            InstStatsd.settings[:#{method}] = value
-          end
+          def #{method}                              # def mask
+            InstStatsd.settings[:#{method}]          #  InstStatsd.settings[:mask]
+          end                                        # end
+                                                     #
+          def #{method}=(value)                      # def mask=(value)
+            InstStatsd.settings[:#{method}] = value  #  InstStatsd.settings[:mask] = value
+          end                                        # end
         RUBY
       end
 
@@ -38,12 +38,12 @@ module InstStatsd
         # to be consistent with ActionPack, measure in milliseconds
         elapsed *= 1000
 
-        block_stat.stats = cookies.map { |(name, cookie)| [name, Counter.counters[name].finalize_count(cookie)] }.to_h
-        block_stat.stats['total'] = elapsed
+        block_stat.stats = cookies.to_h { |(name, cookie)| [name, Counter.counters[name].finalize_count(cookie)] }
+        block_stat.stats["total"] = elapsed
         # we need to make sure to report exclusive timings, even if nobody called us re-entrantly
         block_stat.subtract_exclusives({}) if category
         block_stat.report
-        logger.log(block_stat, "STATSD #{key}") if logger
+        logger&.log(block_stat, "STATSD #{key}")
         # -1 is ourselves; we want to subtract from the block above us
         stack(category)[-2].subtract_exclusives(block_stat.stats) if category && stack(category)[-2]
 
@@ -59,6 +59,5 @@ module InstStatsd
         Thread.current[:stats_block_stack][category] ||= []
       end
     end
-
   end
 end

data/lib/inst_statsd/counter.rb

@@ -12,10 +12,9 @@ module InstStatsd
       end
     end
 
-    attr_reader :key
-    attr_reader :blocked_names
+    attr_reader :key, :blocked_names
 
-    def initialize(key, blocked_names=[], tags: {}, short_stat: nil)
+    def initialize(key, blocked_names = [], tags: {}, short_stat: nil)
       @blocked_names = blocked_names
       @key = key
       @tls_key = "statsd.#{key}"
@@ -41,6 +40,5 @@ module InstStatsd
     def accepted_name?(name)
       !blocked_names.include?(name)
     end
-
   end
 end

data/lib/inst_statsd/default_tracking.rb

@@ -4,41 +4,44 @@ require "active_support"
 
 module InstStatsd
   class DefaultTracking
-    def self.track_sql
-      return if @sql_tracker
-      @sql_tracker = InstStatsd::SqlTracker.new(blocked_names: ['SCHEMA'])
-      ActiveSupport::Notifications.subscribe(/sql\.active_record/) {|*args| update_sql_count(*args)}
-    end
+    class << self
+      def track_sql
+        return if @sql_tracker
 
-    def self.track_active_record
-      return if @ar_counter
-      require 'aroi'
+        @sql_tracker = InstStatsd::SqlTracker.new(blocked_names: ["SCHEMA"])
+        ActiveSupport::Notifications.subscribe(/sql\.active_record/) { |*args| update_sql_count(*args) }
+      end
 
-      ::Aroi::Instrumentation.instrument_creation!
-      @ar_counter = InstStatsd::Counter.new('active_record')
-      ActiveSupport::Notifications.subscribe(/instance\.active_record/) {|*args| update_active_record_count(*args)}
-    end
+      def track_active_record
+        return if @ar_counter
 
-    def self.track_cache
-      return if @cache_read_counter
+        require "aroi"
 
-      @cache_read_counter = InstStatsd::Counter.new('cache.read')
-      ActiveSupport::Notifications.subscribe(/cache_read\.active_support/) {|*args| update_cache_read_count(*args)}
-    end
+        ::Aroi::Instrumentation.instrument_creation!
+        @ar_counter = InstStatsd::Counter.new("active_record")
+        ActiveSupport::Notifications.subscribe(/instance\.active_record/) { |*args| update_active_record_count(*args) }
+      end
 
-    private
+      def track_cache
+        return if @cache_read_counter
 
-    def self.update_sql_count(_name, _start, _finish, _id, payload)
-      @sql_tracker.track payload.fetch(:name), payload.fetch(:sql)
-    end
+        @cache_read_counter = InstStatsd::Counter.new("cache.read")
+        ActiveSupport::Notifications.subscribe(/cache_read\.active_support/) { |*args| update_cache_read_count(*args) }
+      end
 
-    def self.update_active_record_count(_name, _start, _finish, _id, payload)
-      @ar_counter.track payload.fetch(:name, '')
-    end
+      private
 
-    def self.update_cache_read_count(_name, _start, _finish, _id, _payload)
-      @cache_read_counter.track "read"
-    end
+      def update_sql_count(_name, _start, _finish, _id, payload)
+        @sql_tracker.track payload.fetch(:name), payload.fetch(:sql)
+      end
 
+      def update_active_record_count(_name, _start, _finish, _id, payload)
+        @ar_counter.track payload.fetch(:name, "")
+      end
+
+      def update_cache_read_count(_name, _start, _finish, _id, _payload)
+        @cache_read_counter.track "read"
+      end
+    end
   end
 end

data/lib/inst_statsd/event.rb

@@ -44,7 +44,7 @@ module InstStatsd
       instance.event(
         title,
         text,
-        {
+        **{
           alert_type: alert_type,
           priority: priority,
           date_happened: date_happened,

data/lib/inst_statsd/null_logger.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module InstStatsd
   class NullLogger < Logger
-    def initialize(*args)
+    def initialize(*) # rubocop:disable Lint/MissingSuper
     end
 
-    def add(*args, &block)
-    end
+    def add(*); end
   end
 end

data/lib/inst_statsd/request_logger.rb

@@ -2,26 +2,24 @@
 
 module InstStatsd
   class RequestLogger
-
     def initialize(logger)
       @logger = logger || InstStatsd::NullLogger.new
     end
 
-    def log(request_stat, header=nil)
+    def log(request_stat, header = nil)
       @logger.info(build_log_message(request_stat, header))
     end
 
-    def build_log_message(request_stat, header=nil)
+    def build_log_message(request_stat, header = nil)
       header ||= "STATSD"
       message = "[#{header}]"
       request_stat.stats.each do |(name, value)|
-        message += " (#{name.to_s.gsub('.', '_')}: #{"%.2f" % value})"
+        message += " (#{name.to_s.tr(".", "_")}: #{format("%.2f", value)})"
       end
       request_stat.exclusive_stats&.each do |(name, value)|
-        message += " (exclusive_#{name.to_s.gsub('.', '_')}: #{"%.2f" % value})"
+        message += " (exclusive_#{name.to_s.tr(".", "_")}: #{format("%.2f", value)})"
       end
       message
     end
-
   end
 end

data/lib/inst_statsd/request_stat.rb

@@ -2,7 +2,7 @@
 
 module InstStatsd
   class RequestStat < BlockStat
-    def initialize(name, start, finish, id, payload, statsd=InstStatsd::Statsd)
+    def initialize(name, start, finish, id, payload, statsd = InstStatsd::Statsd)
       super(nil, statsd)
       @name = name
       @start = start
@@ -15,21 +15,22 @@ module InstStatsd
     def common_key
       common_key = super
       return common_key if common_key
+
       if @statsd.data_dog?
         self.common_key = "request"
         self.short_stat = "request"
-        self.tags[:controller] = controller if controller
-        self.tags[:action] = action if action
-        self.tags[:status] = status if status
-      else
-        self.common_key = "request.#{controller}.#{action}" if controller && action
+        tags[:controller] = controller if controller
+        tags[:action] = action if action
+        tags[:status] = status if status
+      elsif controller && action
+        self.common_key = "request.#{controller}.#{action}"
       end
     end
 
     def report
-      stats['total'] = total
-      stats['view'] = view_runtime if view_runtime
-      stats['db'] = db_runtime if db_runtime
+      stats["total"] = total
+      stats["view"] = view_runtime if view_runtime
+      stats["db"] = db_runtime if db_runtime
       super
     end
 
@@ -42,30 +43,29 @@ module InstStatsd
     end
 
     def controller
-      @payload.fetch(:params, {})['controller']
+      @payload.fetch(:params, {})["controller"]
     end
 
     def action
-      @payload.fetch(:params, {})['action']
+      @payload.fetch(:params, {})["action"]
     end
 
     def status
       status = @payload.fetch(:status, 0)
       # Only return status group to reduce the number of indexed custom metrics (and cost) of datadog
-      return '1XX' if status >= 100 and status < 200
-      return '2XX' if status >= 200 and status < 300
-      return '3XX' if status >= 300 and status < 400
-      return '4XX' if status >= 400 and status < 500
-      return '5XX' if status >= 500 and status < 600
+      return "1XX" if (status >= 100) && (status < 200)
+      return "2XX" if (status >= 200) && (status < 300)
+      return "3XX" if (status >= 300) && (status < 400)
+      return "4XX" if (status >= 400) && (status < 500)
+      return "5XX" if (status >= 500) && (status < 600)
+
       nil
     end
 
     def total
-      if (!@finish || !@start)
-        return 0
-      end
+      return 0 if !@finish || !@start
+
       (@finish - @start) * 1000
     end
-
   end
 end

data/lib/inst_statsd/request_tracking.rb

@@ -2,28 +2,29 @@
 
 module InstStatsd
   class RequestTracking
+    class << self
+      def enable(logger: nil)
+        @logger = RequestLogger.new(logger)
+        track_timing
+      end
 
-    def self.enable(logger: nil)
-      @logger = RequestLogger.new(logger)
-      track_timing
-    end
-
-    private
+      private
 
-    def self.track_timing
-      ActiveSupport::Notifications.subscribe(/start_processing\.action_controller/, &method(:start_processing))
-      ActiveSupport::Notifications.subscribe(/process_action\.action_controller/, &method(:finalize_processing))
-    end
+      def track_timing
+        ActiveSupport::Notifications.subscribe(/start_processing\.action_controller/, &method(:start_processing))
+        ActiveSupport::Notifications.subscribe(/process_action\.action_controller/, &method(:finalize_processing))
+      end
 
-    def self.start_processing(*_args)
-      @cookies = Counter.counters.map { |(name, counter)| [name, counter.start] }
-    end
+      def start_processing(*_args)
+        @cookies = Counter.counters.map { |(name, counter)| [name, counter.start] }
+      end
 
-    def self.finalize_processing *args
-      request_stat = InstStatsd::RequestStat.new(*args)
-      request_stat.stats = @cookies.map { |(name, cookie)| [name, Counter.counters[name].finalize_count(cookie)] }.to_h
-      request_stat.report
-      @logger.log(request_stat)
+      def finalize_processing *args
+        request_stat = InstStatsd::RequestStat.new(*args)
+        request_stat.stats = @cookies.to_h { |(name, cookie)| [name, Counter.counters[name].finalize_count(cookie)] }
+        request_stat.report
+        @logger.log(request_stat)
+      end
     end
   end
 end

data/lib/inst_statsd/sql_tracker.rb

@@ -2,27 +2,26 @@
 
 module InstStatsd
   class SqlTracker
-
     attr_reader :blocked_names, :read_counts, :write_counts, :cache_counts
 
-    def initialize(opts=nil)
+    def initialize(opts = nil)
       opts ||= {}
       @blocked_names = opts.fetch(:blocked_names, [])
-      @read_counts = opts.fetch(:read_counter, InstStatsd::Counter.new('sql.read'))
-      @write_counts = opts.fetch(:write_counter, InstStatsd::Counter.new('sql.write'))
-      @cache_counts = opts.fetch(:cache_counter, InstStatsd::Counter.new('sql.cache'))
+      @read_counts = opts.fetch(:read_counter, InstStatsd::Counter.new("sql.read"))
+      @write_counts = opts.fetch(:write_counter, InstStatsd::Counter.new("sql.write"))
+      @cache_counts = opts.fetch(:cache_counter, InstStatsd::Counter.new("sql.cache"))
     end
 
     def start
       [read_counts, write_counts, cache_counts].map(&:start)
     end
 
-    def track name, sql
+    def track(name, sql)
       return unless sql && accepted_name?(name)
 
-      if name.match(/CACHE/)
+      if name.include?("CACHE")
         cache_counts.track name
-      elsif truncate(sql).match(/SELECT/) || name.match(/LOAD/)
+      elsif truncate(sql).include?("SELECT") || name.include?("LOAD")
         read_counts.track(sql)
       else
         write_counts.track(sql)
@@ -43,10 +42,9 @@ module InstStatsd
       !!(name && !blocked_names.include?(name))
     end
 
-    def truncate(sql, length=15)
-      sql ||= ''
+    def truncate(sql, length = 15)
+      sql ||= ""
       sql.strip[0..length]
     end
-
   end
 end

data/lib/inst_statsd/statsd.rb

@@ -10,29 +10,33 @@
 #   InstStatsd::Statsd.timing("my_stat", ms)
 #
 # Configured in config/statsd.yml, see config/statsd.yml.example
-# At least a host needs to be defined for the environment, all other config is optional
+# At least a host needs to be defined for the environment, all other config is
+# optional
 #
 # If a namespace is defined in statsd.yml, it'll be prepended to the stat name.
-# The hostname of the server will be appended to the stat name, unless `append_hostname: false` is specified in the config.
-# So if the namespace is "canvas" and the hostname is "app01", the final stat name of "my_stat" would be "stats.canvas.my_stat.app01"
-# (assuming the default statsd/graphite configuration)
+# The hostname of the server will be appended to the stat name, unless
+# `append_hostname: false` is specified in the config.
+# So if the namespace is "canvas" and the hostname is "app01", the final stat
+# name of "my_stat" would be "stats.canvas.my_stat.app01" (assuming the default
+# statsd/graphite configuration)
 #
 # If dog_tags is set in statsd.yml, it'll use the tags param and will use
 # Data Dog instead of Statsd
 #
-# If statsd isn't configured and enabled, then calls to InstStatsd::Statsd.* will do nothing and return nil
+# If statsd isn't configured and enabled, then calls to InstStatsd::Statsd.*
+# will do nothing and return nil
 
 module InstStatsd
   module Statsd
     extend InstStatsd::Event
 
     # replace "." in key names with another character to avoid creating spurious sub-folders in graphite
-    def self.escape(str, replacement = '_')
-      str.respond_to?(:gsub) ? str.gsub('.', replacement) : str
+    def self.escape(str, replacement = "_")
+      str.respond_to?(:gsub) ? str.gsub(".", replacement) : str
     end
 
     def self.hostname
-      @hostname ||= Socket.gethostname.split('.').first
+      @hostname ||= Socket.gethostname.split(".").first
     end
 
     def self.dog_tags
@@ -41,50 +45,49 @@ module InstStatsd
 
     %w[increment decrement count gauge timing].each do |method|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def self.#{method}(stat, *args, tags: {}, short_stat: nil)
-        if self.instance
-          if Array === stat
-            stat.each do |st|
-              self.#{method}(st, *args, tags: tags, short_stat: nil)
-            end
-            return
-          end
-
-          if self.append_hostname?
-            stat_name = "\#{stat}.\#{hostname}"
-          else
-            stat_name = stat.to_s
-          end
-
-          if data_dog?
-            tags ||= {}
-            tags.merge!(dog_tags) if tags.is_a? Hash
-            tags = convert_tags(tags)
-            tags << 'host:' unless self.append_hostname?
-            short_stat ||= stat_name
-            opts = { tags: tags }
-            opts[:sample_rate] = args.pop if args.length == 2
-            args << opts
-            self.instance.#{method}(short_stat, *args)
-          else
-            self.instance.#{method}(stat_name, *args)
-          end
-        else
-          nil
-        end
-      end
+        def self.#{method}(stat, *args, tags: {}, short_stat: nil)      # def self.increment(stat, *args, tags: {}, short_stat: nil)
+          if self.instance                                              #   if self.instance
+            if Array === stat                                           #     if Array === stat
+              stat.each do |st|                                         #       stat.each do |st|
+                self.#{method}(st, *args, tags: tags, short_stat: nil)  #        self.increment(st, *args, tags: tags, short_stat: nil)
+              end                                                       #       end
+              return                                                    #       return
+            end                                                         #     end
+                                                                        #
+            if self.append_hostname?                                    #     if self.append_hostname?
+              stat_name = "\#{stat}.\#{hostname}"                       #       stat_name = "\#{stat}.\#{hostname}"
+            else                                                        #     else
+              stat_name = stat.to_s                                     #       stat_name = stat.to_s
+            end                                                         #     end
+                                                                        #
+            if data_dog?                                                #     if data_dog?
+              tags = tags ? tags.dup : {}                               #       tags ||= {}
+              tags.merge!(dog_tags) if tags.is_a? Hash                  #       tags.merge!(dog_tags) if tags.is_a? Hash
+              tags = convert_tags(tags)                                 #       tags = convert_tags(tags)
+              tags << 'host:' unless self.append_hostname?              #       tags << 'host:' unless self.append_hostname?
+              short_stat ||= stat_name                                  #       short_stat ||= stat_name
+              opts = { tags: tags }                                     #       opts = { tags: tags }
+              opts[:sample_rate] = args.pop if args.length == 2         #       opts[:sample_rate] = args.pop if args.length == 2
+              args << opts                                              #       args << opts
+              self.instance.#{method}(short_stat, *args)                #       self.instance.increment(short_stat, *args)
+            else                                                        #     else
+              self.instance.#{method}(stat_name, *args)                 #       self.instance.increment(stat_name, *args)
+            end                                                         #     end
+          else                                                          #   else
+            nil                                                         #     nil
+          end                                                           #   end
+        end                                                             # end
       RUBY
     end
 
     def self.convert_tags(tags)
       new_tags = []
-      if tags.is_a? Hash
-        tags.each do |tag, v|
-          new_tags << "#{tag}:#{v}"
-        end
-      else
-        return tags
+      return tags unless tags.is_a? Hash
+
+      tags.each do |tag, v|
+        new_tags << "#{tag}:#{v}"
       end
+
       new_tags
     end
 
@@ -97,6 +100,7 @@ module InstStatsd
 
     def self.batch
       return yield unless (old_instance = instance)
+
       old_instance.batch do |batch|
         Thread.current[:inst_statsd] = batch
         yield
@@ -113,19 +117,24 @@ module InstStatsd
         statsd_settings = InstStatsd.settings
         if statsd_settings.key?(:dog_tags)
           @data_dog = true
-          host = statsd_settings[:host] || 'localhost'
+          host = statsd_settings[:host] || "localhost"
           port = statsd_settings[:port] || 8125
-          require 'datadog/statsd'
-          @statsd = ::Datadog::Statsd.new(host, port, namespace: statsd_settings[:namespace])
-          self.dog_tags.replace(statsd_settings[:dog_tags] || {})
-          @append_hostname = !statsd_settings.key?(:append_hostname) || !!statsd_settings[:append_hostname]
+          socket_path = statsd_settings[:socket_path]
+          require "datadog/statsd"
+          @statsd = if socket_path
+                      Datadog::Statsd.new(socket_path: socket_path, namespace: statsd_settings[:namespace])
+                    else
+                      Datadog::Statsd.new(host, port, namespace: statsd_settings[:namespace])
+                    end
+          dog_tags.replace(statsd_settings[:dog_tags] || {})
+          @append_hostname = statsd_settings[:append_hostname]
         elsif statsd_settings && statsd_settings[:host]
           @statsd = ::Statsd.new(statsd_settings[:host])
           @statsd.port = statsd_settings[:port] if statsd_settings[:port]
           @statsd.namespace = statsd_settings[:namespace] if statsd_settings[:namespace]
           @statsd.batch_size = statsd_settings[:batch_size] if statsd_settings.key?(:batch_size)
           @statsd.batch_byte_size = statsd_settings[:batch_byte_size] if statsd_settings.key?(:batch_byte_size)
-          @append_hostname = !statsd_settings.key?(:append_hostname) || !!statsd_settings[:append_hostname]
+          @append_hostname = statsd_settings[:append_hostname]
         else
           @statsd = nil
         end

data/lib/inst_statsd/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module InstStatsd
-  VERSION = "3.0.2"
+  VERSION = "3.0.3"
 end