datadog-statsd-schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb6a6aae5d3d756626118bbf0215ea4a0fb6701a547d6543966480ef50512b2e
+  data.tar.gz: 7115508fd6fb2d1945f26472c7d8a9c718fed5c7096cdc037faeeaf1112da822
+SHA512:
+  metadata.gz: e826c7e448f1a44ec76eba91b2643f04deb1093a89507a531dd051fc2dac6ace95482c30691295a219d740c217ede37c436d3328a29d256fb0550f53bf412727
+  data.tar.gz: 673df2c80be0e15af9a09cdd780c96092949ce8b00ad7bb1290d3e61efc1e7d46463ac0011db9b297335c425cf6ba693fcc9b17f1cc0b920dae8d7513a791d21

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,20 @@
+inherit_from: .rubocop_todo.yml
+
+plugins:
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false

data/.rubocop_todo.yml

@@ -0,0 +1,227 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2025-05-31 23:20:37 UTC using RuboCop version 1.75.8.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 2
+# Configuration parameters: EnforcedStyle, AllowedGems, Include.
+# SupportedStyles: Gemfile, gems.rb, gemspec
+# Include: **/*.gemspec, **/Gemfile, **/gems.rb
+Gemspec/DevelopmentDependencies:
+  Exclude:
+    - 'datadog-statsd-schema.gemspec'
+
+# Offense count: 4
+Lint/DuplicateMethods:
+  Exclude:
+    - 'lib/datadog/statsd/schema/schema_builder.rb'
+
+# Offense count: 1
+Lint/FloatComparison:
+  Exclude:
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 8
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
+Metrics/AbcSize:
+  Max: 48
+
+# Offense count: 4
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ClassLength:
+  Max: 356
+
+# Offense count: 6
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/CyclomaticComplexity:
+  Max: 21
+
+# Offense count: 5
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ModuleLength:
+  Max: 577
+
+# Offense count: 2
+# Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
+Metrics/ParameterLists:
+  Max: 7
+
+# Offense count: 5
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/PerceivedComplexity:
+  Max: 20
+
+# Offense count: 3
+# This cop supports unsafe autocorrection (--autocorrect-all).
+# Configuration parameters: EnforcedStyleForLeadingUnderscores.
+# SupportedStylesForLeadingUnderscores: disallowed, required, optional
+Naming/MemoizedInstanceVariableName:
+  Exclude:
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 3
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
+Naming/MethodParameterName:
+  Exclude:
+    - 'examples/shared.rb'
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 3
+# Configuration parameters: NamePrefix, ForbiddenPrefixes, AllowedMethods, MethodDefinitionMacros, UseSorbetSigs.
+# NamePrefix: is_, has_, have_, does_
+# ForbiddenPrefixes: is_, has_, have_, does_
+# AllowedMethods: is_a?
+# MethodDefinitionMacros: define_method, define_singleton_method
+Naming/PredicateName:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/datadog/statsd/schema/namespace.rb'
+
+# Offense count: 4
+# Configuration parameters: Prefixes, AllowedPatterns.
+# Prefixes: when, with, without
+RSpec/ContextWording:
+  Exclude:
+    - 'spec/datadog/statsd/schema/namespace_spec.rb'
+
+# Offense count: 15
+# Configuration parameters: CountAsOne.
+RSpec/ExampleLength:
+  Max: 19
+
+# Offense count: 4
+# Configuration parameters: Max, AllowedIdentifiers, AllowedPatterns.
+RSpec/IndexedLet:
+  Exclude:
+    - 'spec/datadog/statsd/schema/namespace_spec.rb'
+
+# Offense count: 36
+# Configuration parameters: .
+# SupportedStyles: have_received, receive
+RSpec/MessageSpies:
+  EnforcedStyle: receive
+
+# Offense count: 4
+RSpec/MultipleExpectations:
+  Max: 3
+
+# Offense count: 39
+# Configuration parameters: AllowSubject.
+RSpec/MultipleMemoizedHelpers:
+  Max: 9
+
+# Offense count: 38
+# Configuration parameters: EnforcedStyle, IgnoreSharedExamples.
+# SupportedStyles: always, named_only
+RSpec/NamedSubject:
+  Exclude:
+    - 'spec/datadog/statsd/schema/namespace_spec.rb'
+    - 'spec/datadog/statsd/schema/schema_builder_spec.rb'
+
+# Offense count: 2
+RSpec/RepeatedExampleGroupBody:
+  Exclude:
+    - 'spec/datadog/statsd/schema/tag_definition_spec.rb'
+
+# Offense count: 5
+# Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
+RSpec/VerifiedDoubles:
+  Exclude:
+    - 'spec/datadog/statsd/schema/metric_definition_spec.rb'
+    - 'spec/datadog/statsd/schema_spec.rb'
+
+# Offense count: 8
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/datadog/statsd/emitter.rb'
+    - 'lib/datadog/statsd/schema.rb'
+    - 'lib/datadog/statsd/schema/errors.rb'
+    - 'lib/datadog/statsd/schema/metric_definition.rb'
+    - 'lib/datadog/statsd/schema/namespace.rb'
+    - 'lib/datadog/statsd/schema/schema_builder.rb'
+    - 'lib/datadog/statsd/schema/tag_definition.rb'
+
+# Offense count: 1
+# This cop supports unsafe autocorrection (--autocorrect-all).
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: always, always_true, never
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - '**/*.arb'
+    - 'exe/datadog-statsd-schema'
+
+# Offense count: 3
+# This cop supports unsafe autocorrection (--autocorrect-all).
+# Configuration parameters: AllowedReceivers.
+# AllowedReceivers: Thread.current
+Style/HashEachMethods:
+  Exclude:
+    - 'lib/datadog/statsd/schema/namespace.rb'
+
+# Offense count: 1
+# Configuration parameters: MinBranchesCount.
+Style/HashLikeCase:
+  Exclude:
+    - 'spec/datadog/statsd/schema/schema_builder_spec.rb'
+
+# Offense count: 3
+# This cop supports safe autocorrection (--autocorrect).
+Style/IfUnlessModifier:
+  Exclude:
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 1
+# This cop supports unsafe autocorrection (--autocorrect-all).
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: literals, strict
+Style/MutableConstant:
+  Exclude:
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 1
+Style/OpenStructUse:
+  Exclude:
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 1
+# This cop supports unsafe autocorrection (--autocorrect-all).
+# Configuration parameters: ConvertCodeThatCanStartToReturnNil, AllowedMethods, MaxChainLength.
+# AllowedMethods: present?, blank?, presence, try, try!
+Style/SafeNavigation:
+  Exclude:
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 1
+# Configuration parameters: Max.
+Style/SafeNavigationChainLength:
+  Exclude:
+    - 'lib/datadog/statsd/emitter.rb'
+
+# Offense count: 2
+# This cop supports unsafe autocorrection (--autocorrect-all).
+Style/SlicingWithRange:
+  Exclude:
+    - 'lib/datadog/statsd/schema/namespace.rb'
+
+# Offense count: 5
+# This cop supports unsafe autocorrection (--autocorrect-all).
+# Configuration parameters: AllowMethodsWithArguments, AllowedMethods, AllowedPatterns, AllowComments.
+# AllowedMethods: define_method
+Style/SymbolProc:
+  Exclude:
+    - 'spec/datadog/statsd/schema/schema_builder_spec.rb'
+    - 'spec/datadog/statsd/schema_spec.rb'
+
+# Offense count: 4
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns, SplitStrings.
+# URISchemes: http, https
+Layout/LineLength:
+  Max: 140

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-05-30
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Konstantin Gredeskoul
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,360 @@
+[![RSpec and Rubocop](https://github.com/kigster/datadog-statsd-schema/actions/workflows/ruby.yml/badge.svg)](https://github.com/kigster/datadog-statsd-schema/actions/workflows/ruby.yml)
+
+# Datadog::Statsd::Schema
+
+This is a wrapper around  [dogstatsd-ruby](https://github.com/DataDog/dogstatsd-ruby) gem that sends custom metrics via StatsD, with additional layer of validation based on a configurable schemas. Schemas can validate allowed metric names, associated tag and tag values. This approach can guide an organization towards a clear declarative approach to metrics and their tags, and then emitting them from within the application with the insurance that any invalid value would raise an exception. 
+
+We invite you to explore some of the provided [examples](./examples/README.md) which can be run from project's root, and are described in the linked README.
+
+## Introduction
+
+This is an extension to gem [dogstatsd-ruby](https://github.com/DataDog/dogstatsd-ruby) which enhances the original with a robust schema definition for both the custom metrics being sent, and the tags allowed (or required) to attach to the metric. 
+
+There are several interfaces to `Datadog::Statsd` instance — you can use the class methods of `Datadog::Statsd::Emitter`, and pass the typical statsd methods. But you can also use an instance of this class, which adds a number of features and powerful shortcuts. 
+
+If you do not pass the schema argument to the emitter, it will act as a wrapper around `Datadog::Statsd` instance: it will merge the global and local tags together, it will concatenate metric names together, so it's quite useful on it' on.
+
+But the real power comes from defining a Schema of metrics and tags, and providing the schema to the Emitter as a constructor argument. In that case every metric send will be validated against the schema.
+ 
+## Metric Types
+
+> For more information about the metrics, please see the [Datadog Documentation](https://docs.datadoghq.com/metrics/custom_metrics/dogstatsd_metrics_submission/?tab=ruby).
+
+There are 5 total metric types you can send with Statsd, and it's important to understand the differences:
+
+* `COUNT` (eg, `Datadog::Statsd::Emitter.increment('emails.sent', by: 2)`)
+* `GAUGE` (eg, `Datadog::Statsd::Emitter.gauge('users.on.site', 100)`)
+* `HISTOGRAM` (eg, `Datadog::Statsd::Emitter.histogram('page.load.time', 100)`)
+* `DISTRIBUTION` (eg,`Datadog::Statsd::Emitter.distribution('page.load.time', 100)`)
+* `SET` (eg, `Datadog::Statsd::Emitter.set('users.unique', '12345')`)
+
+NOTE: that `HISTOGRAM` converts your metric into FIVE separate metrics (with suffixes .`max`, .`median`, `avg`, .`count`, `p95`), while `DISTRIBUTION` explodes into TEN separate metrics (see the documentation). Do NOT use SET unless you know what you are doing.
+
+You can send metrics via class methods of `Datadog::Statsd::Emitter`, or by instantiating the class.
+
+## Sending Metrics 
+
+### Class Methods
+
+This is the most straightforward way of using this gem. You can just pass your metric names and tags to the standard operations on Statsd, just like so:
+
+```ruby
+  require 'datadog/statsd'
+  require 'datadog/statsd/schema'
+
+  Datadog::Statsd::Emitter.increment(
+    'marathon.started.total', 
+    by: 7, 
+    tags: { 
+        course: "sf-marathon", 
+        length: 26.212, 
+        units: "miles" 
+    },
+    schema: ....
+  )
+```
+
+As you can see, the API is identical to `Datadog::Statsd`. The main difference is that, if you provide a schema argument, the metric `marathon.started.total` must be pre-declared using the schema DSL language. In addition, the metric type ("count") and all of the tags and their possible values must be predeclared in the schema. Schema does support opening up a tag to any number of values, but that is not recommended.
+
+So let's look at a more elaborate use case.
+
+### Defining Schema 
+
+Below is an example of configuring the gem by creating a schema using the provided DSL. This can be a single global schema or assigned to a specific Statsd Sender, although you can have any number of Senders of type `Datadog::Statsd::Emitter` that map to a new connection and new defaults.
+
+```ruby
+  require 'etc'
+  require 'git'
+
+  require 'datadog/statsd'
+  require 'datadog/statsd/schema'
+
+  # Define the global statsd instance that we'll use to send data through
+  $statsd = ::Datadog::Statsd.new(
+    'localhost', 8125, 
+    delay_serialization: true
+  )
+
+  # Configure the schema with global tags and the above-created Statsd instance
+  Datadog::Statsd::Schema.configure do |config|
+    # This configures the global tags that will be attached to all methods
+    config.tags = { 
+      env: "development",
+      arch: Etc.uname[:machine],
+      version: Git.open('.').object('HEAD').sha
+    }
+    
+    config.statsd = $statsd
+  end
+
+  # Now we'll create a Schema using the provided Schema DSL:
+  schema = Datadog.schema do
+    # Transformers can be attached to the tags, and applied before the tags are submitted
+    # or validated.
+    transformers do
+      underscore: ->(text) { text.underscore },
+      downcase: ->(text) { text.downcase }
+    end
+
+    namespace :marathon do
+      tags do
+        tag :course, 
+            values: ["san francisco", "boston", "new york"],         
+            transform: %i[downcase underscore],
+
+        tag :marathon_type, values: %w[half full]
+        tag :status, values: %w[finished no-show incomplete]
+        tag :sponsorship, values: %w[nike cocacola redbull]
+      end
+
+      metrics do 
+        # This defines a single metric "marathon.started.total"
+        namespace :started do
+          counter :total do
+            description "Incrementing - the total number of people who were registered for this marathon"
+            tags required: %i[ course marathon_type ],
+                  allowed:  %i[ sponsorship ]
+          end
+        end
+
+        # defines two metrics: a counter metric named "marathon.finished.total" and
+        # a distribution metric "marathon.finished.duration"
+        namespace :finished do
+          counter :total, inherit_tags: "marathon.started.total",
+            description "The number of people who finished a given marathon"
+            tags required: %i[ status ]
+          end
+
+          distribution :duration, units: "minutes", inherit_tags: "marathon.finished.count" do
+            description "The distribution of all finish times registered."
+          end
+        end   
+      end
+    end
+  end
+
+  my_sender = Datadog.emitter(
+    metric: 'marathon',
+    schema: schema,
+    validation_mode: :strict,
+    tags: { marathon_type: :full, course: "san-francisco" }
+  )
+
+  my_sender.increment('started.total', by: 43579) # register all participants at start
+  # time passes, first runners start to arrive
+  my_sender.increment('finished.total') # register one at a time
+  my_sender.distribution('finished.duration', 33.21, tags: { sponsorship: 'nike' })
+  ... 
+  my_sender.increment('finished.total')
+  my_sender.distribution('finished.duration', 35.09, tags: { sponsorship: "redbull" })
+```
+
+In this case, the schema will validate that the metrics are named `marathon.finished.total` and `marathon.finished.duration`, and that their tags are appropriately defined.
+
+```ruby
+  finish_sender = Datadog.emitter(
+    schema: schema,
+    validation_mode: :warn,
+    metric: "marathon.finished", 
+    tags: { marathon_type: :full, course: "san-francisco" }
+  )
+  finish.increment("total")
+  finish.distribution("duration", 34)
+```
+
+The above code will transmit the following metric, with the following tags:
+
+```ruby
+$statsd.increment(
+  "marathon.finished.total", 
+  tags: { marathon_type: :full, course: "san-francisco" }
+)
+
+$statsd.distribution(
+  "marathon.finished.duration", 
+  tags: { marathon_type: :full, course: "san-francisco" }
+)
+```
+
+### Validation Mode
+
+There are four validation modes you can pass to an emitter to accompany a schema:
+
+1. `:strict` — raise an exception when anything is out of the ordinary is passed
+2. `:warn` — print to stderr and continue 
+3. `:drop` — drop this metric
+4. `:off` — no validation, as if schema was not even passed.
+
+### An Example Tracking Web Performance
+
+```ruby
+ Datadog::Statsd::Schema.configure do |config|
+    config.statsd = $statsd
+    config.schema = Datadog::Statsd::Schema.new do
+      namespace "web" do
+        namespace "request" do
+          tags do
+            tag :uri,
+                values: %r{.*}
+
+            tag :logged_in,
+                values: %w[logged_in logged_out]
+
+            tag :billing_plan,
+                values: %w[premium trial free]
+
+            tag :controller, 
+                values: %r{[a-z.]*}, 
+                transform: [ :underscore, :downcase ]
+
+            tag :action, 
+                values: %r{[a-z.]*}, 
+                transform: [ :underscore, :downcase ]
+
+            tag :method, 
+                values: %i[get post put patch delete head options trace connect], 
+                transform: [ :downcase ]
+
+            tag :status_code, 
+                type: :integer, 
+                validate: ->(code) { (100..599).include?(code) }
+          end
+          
+          metrics do
+            # This distribution allows tracking of the latency of the request.
+            distribution :duration do
+              description "HTTP request processing time in milliseconds"
+              tags allowed: %w[controller action method status_code region]
+                  required: %w[controller]
+            end
+          
+            # This counter allows tracking the frequency of each controller/action
+            counter :total, inherit_tags: :duration do
+              description "Total number of requests received"
+            end
+          end
+        end
+      end
+    end
+  end
+```
+
+
+Let's say this monitor only tracks requests from logged in premium users,  then you can provide those tags here, and they will be sent together with individual invocations:
+
+```ruby
+  # We'll use the shorthand version to create this Emitter.
+  # It's equivalent to *Datadog::Statsd::Emitter.new*
+  traffic_monitor = Datadog.emitter(
+    self,
+    metric: "web.request", 
+    tags: { billing_plan: :premium, logged_in: :logged_in }
+  )
+
+  my_sender.increment('total', tags: { uri: '/home/settings', method: :get } ) 
+  my_sender.distribution('duration', tags: { uri: '/home/settings', method: :get } ) 
+
+  my_sender.increment('total', tags: { uri: '/app/calendar', method: :post} )
+  my_sender.distribution('duration', tags: { uri: '/app/calendar', method: :post } )
+```
+      
+The above code will send two metrics: `web.request.total` as a counter, tagged with: `{ billing_plan: :premium, logged_in: :logged_in, uri: '/home/settings' }` and the second time for the `uri: '/app/calendar'`. 
+
+### Emitter
+
+You can create instances of this class and use the instance to emit custom metrics. You may want to do this, instead of using the class methods directly, for two reasons:
+
+ 1. You want to send metrics from several places in the codebase, but have them share the "emitter" tag (which i.e. defines the source, a class, or object)emitting the metric, or any other tags for that matter.
+
+ 2. You want to send metrics with a different sample rate than the defaults.
+
+In both cases, you can create an instance of this class and use it to emit metrics.
+
+#### Naming Metrics
+
+Please remember that naming *IS* important. Good naming is self-documenting, easy to slice the data by, and easy to understand and analyze. Keep the number of unique metric names down, number of tags down, and the number of possible tag values should always be finite. If in doubt, set a tag, instead of creating a new metric.
+
+#### Example — Tracking email delivery 
+
+Imagine that we want to track email delivery. But we have many types of emails that we send. Instead of creating new metric for each new email type, use the tag "email_type" to specify what type of email it is.
+
+Keep metric name list short, eg: "emails.queued", "emails.sent", "emails.delivered" are good metrics as they define a distinctly unique events. However, should you want to differentiate between different types of emails, you could theoretically do the following: (BAD EXAMPLE, DO NOT FOLLOW) — "emails.sent.welcome", "emails.sent.payment". But this example conflates two distinct events into a single metric. Instead, we should use tags to set event properties, such as what type of email that is.
+
+```ruby
+
+    emails_emitter = Datadog.emitter(
+      self,
+      metric: 'emails'
+    )
+
+    emails_emitter.increment('queued.total')
+    emails_emitter.increment('delivered.total', by: count)
+    emails_emitter.gauge('queue.size', EmailQueue.size)
+```
+
+#### What's the Emitter Constructor Arguments?
+
+The first argument to the `Emitter.new()` or `Datadog.emitter()` (those are equivalent) is an object or a string or a class that's converted to a tag called `emitter`. This is the source class or object that sent the metric. The same mwtric may come from various places in your code, and `emitter` tag allows you to differentiate between them.
+
+Subsequent arguments are hash arguments. 
+
+ * `metric` — The (optional) name of the metric to track. If set to, eg. `emails`, then any subsequent method sending metric will prepend `emails.` to it, for example:
+
+```ruby
+emitter.increment('sent.total', by: 3)
+```
+
+Will actually increment the metric `emails.sent.total`.
+
+#### Other Examples
+
+```ruby
+
+  Datadog.emitter(self)
+    .increment('emails.sent', by: 2)
+
+  Datadog.emitter(ab_test: { 'login_test_2025' => 'control' })
+    .increment('users.logged_in')
+  # => tags: { ab_test_name: 'login_test_2025', 
+  #            ab_test_group: 'control' } 
+
+  Datadog.emitter(SessionsController, metric: 'users')
+     .gauge('logged_in', 100)
+
+  sessions = Datadog.emitter(SessionsController, metric: 'users')
+  # => tags: { emitter: "sessions_controller" }
+  sessions.gauge('active', 100)
+  sessions.distribution('active.total', 114)
+```
+
+## Installation
+
+
+```bash
+bundle add datadog-statsd-schema
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install datadog-statsd-schema
+```
+
+## Usage
+
+1. Define your metrics and tagging schema
+2. Create as many "emitters" as necessary and start sending!
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/kigster/datadog-statsd-schema](https://github.com/kigster/datadog-statsd-schema)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'timeout'
+
+def shell(*args)
+  puts "running: #{args.join(' ')}"
+  system(args.join(' '))
+end
+
+task :clean do
+  shell('rm -rf pkg/ tmp/ coverage/ doc/ ' )
+end
+
+task gem: [:build] do
+  shell('gem install pkg/*')
+end
+
+task permissions: [:clean] do
+  shell("chmod -v o+r,g+r * */* */*/* */*/*/* */*/*/*/* */*/*/*/*/*")
+  shell("find . -type d -exec chmod o+x,g+x {} \\;")
+end
+
+task build: :permissions
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec