inst_statsd 2.2.0 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4be1145693a7188f19fe5b64206465eeece936dd9220f9185d1d87e5d895e91c
-  data.tar.gz: f9f61e0ceb159ff2dabc3b8bda50e9ab5edb299e94d5ab3fed4a664815137697
+  metadata.gz: a91fe00f6ca513926589fdd5d3cb3f316e26a6fc5bb5b8ceb1a49ba20f42769f
+  data.tar.gz: 82a6dd4759cb55054a20e6c394d19c000b571aabe8df48251f0661fdb86de7ec
 SHA512:
-  metadata.gz: c588cc8d11fc48e12808183efc310f98468b2c1e508e98864c8c796d60a22508fec115694dc56f03a311511e17cd221badff168bfaf77dc414581ca829f62a24
-  data.tar.gz: 7020ddd2f162501c846c280b7e93d4e037479edd7cea347267911607c3da3b578096cb2ef426f0fd86ddeac077b8ded803c7ebe50dd1c501704c9f537ce1e9af
+  metadata.gz: dbddd5f2e3069681cd2f6e4b2843d4c7ea123cbaee2a3537cd35ef4b6fffe8f2c90b20b4bf30d5e109967151d29926ad993597575ee6042942587ef7ba75fa43
+  data.tar.gz: e5d8af2078d7d320732285b3e071c1c18da70e9aeb0cad060eb589b8b1de592d6093fab0d836c74a9380e10df19e3f46090edb73a14bf1a18e8a2e5d95bf51fa

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module InstStatsd
+  # Mix-in methods for supporting DataDog events
+  # See https://docs.datadoghq.com/service_management/events/
+  module Event
+    SUPPORTED_TYPES = %i[
+      deploy
+      feature_disabled
+      feature_enabled
+      provision
+      refresh
+    ].freeze
+
+    def instance; end
+    def data_dog?; end
+    def dog_tags; end
+
+    # This end point allows you to post events to the DatDog event stream.
+    #
+    # @param [String] title Event title
+    # @param [String] text Event text. Supports newlines (+\n+)
+    # @param [String, nil] :type Can be "deploy", "feature_disabled",
+    #   "feature_enabled", "provision", or "refresh"
+    # @param [Hash] :tags tags to be added to event. Note that the
+    #   environment, service, and other data are automatically
+    #   added as tags for you without specifying them here.
+    # @param [Integer, String, nil] :date_happened (nil) Assign a timestamp
+    #   to the event. Default is now when none
+    # @param [String, nil] :priority ('normal') Can be "normal" or "low"
+    # @param [String, nil] :alert_type ('info') Can be "error", "warning", "info" or "success".
+    #
+    # @example Report an event:
+    #   InstStatsd::Statsd.event(
+    #       "Quiz API Deploy",
+    #       "<release> was deployed to Quiz API",
+    #       tags: {foo: 'bar'},
+    #       type: 'deploy',
+    #       alert_type: :success
+    #   )
+    def event(title, text, type: nil, tags: {}, alert_type: nil, priority: nil, date_happened: nil)
+      return unless instance && data_dog?
+
+      instance.event(
+        title,
+        text,
+        **{
+          alert_type: alert_type,
+          priority: priority,
+          date_happened: date_happened,
+          tags: tags_from_opts(tags, type, dog_tags)
+        }.compact
+      )
+    end
+
+    private
+
+    def tags_from_opts(tags, type, dd_tags)
+      custom_tags = tags.merge(dd_tags)
+      custom_tags[:type] = type if SUPPORTED_TYPES.include? type
+      custom_tags.compact
+    end
+  end
+end

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,20 +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
-      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
 
@@ -41,19 +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) && (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,27 +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
@@ -39,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: {}, 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
 
@@ -95,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
@@ -111,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