datadog-statsd-schema 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8ecccf4d0e55d1139596eca6ecfc41cf25a4bcd637aebdb4cb963150aa10ce7
-  data.tar.gz: 002504ebc4073bb7b34a5d979cb49f89d86e8eff5356594046bd3e1e223c8ed6
+  metadata.gz: 252a3536a931724dfbebc6755ddecbb01206794037ccd7d0b3bd91c150b66f6d
+  data.tar.gz: 4a1eafd370b04d5087c72de5694fc01cd0689df6c8b7a280992bae822e3373cc
 SHA512:
-  metadata.gz: b8f866b339297e39236ba1e546f50aff716f46e74d6856386a5de95ace0dfea5e62f060aec4e5e61320dd352a5d0bf971c38be4c7e9ee15ff17ea4b0083ad389
-  data.tar.gz: ff341e1836eebc261125c6cbd42103e359286bcb1bed0ed47fc96df9c2727f8873f6cd31e6e3591ca991b4b977fb9bdae42d5ef228eeebda7847da9129635ea9
+  metadata.gz: 1ceac7e83b4e9678c4751981cc51c8d526e34b9f959971535157536938b6842757a35e7023c859d64df135b4623cf0668048f0a87f55b3a8cb21784eb39ebadb
+  data.tar.gz: 93046e96ae66782fb616d618f8a6c2c6e571eee6f779f1834ee434251a4f9680c47df8c3be75769a9550f0bf001aa699d00040c6923e0d6186299b10f197e024

data/.rubocop.yml

@@ -25,6 +25,3 @@ Layout/LineLength:
 
 Style/Documentation:
   Enabled: false
-
-Metrics/MethodLength:
-  Enabled: false

data/README.md

@@ -141,63 +141,12 @@ end
 Analyze the schema to understand metric costs:
 
 ```bash
-dss analyze --file metrics_schema.rb
+dss analyze --file metrics_schema.rb --color
 ```
 
 **Output:**
-```
-┌──────────────────────────────────────────────────────────────────────────────────────────────┐
-│ Detailed Metric Analysis:                                                                    │
-└──────────────────────────────────────────────────────────────────────────────────────────────┘
-
-  • gauge('web.memory_usage')
-    Expanded names:
-      • web.memory_usage.count
-      • web.memory_usage.min
-      • web.memory_usage.max
-      • web.memory_usage.sum
-      • web.memory_usage.avg
-
-                              Unique tags:   2
-                         Total tag values:   6
-                    Possible combinations:  45
-
- ──────────────────────────────────────────────────────────────────────────────────────────────
-
-  • counter('web.requests.total')
-
-                              Unique tags:   3
-                         Total tag values:   9
-                    Possible combinations:  27
-
- ──────────────────────────────────────────────────────────────────────────────────────────────
-
-  • distribution('web.requests.duration')
-    Expanded names:
-      • web.requests.duration.count
-      • web.requests.duration.min
-      • web.requests.duration.max
-      • web.requests.duration.sum
-      • web.requests.duration.avg
-      • web.requests.duration.p50
-      • web.requests.duration.p75
-      • web.requests.duration.p90
-      • web.requests.duration.p95
-      • web.requests.duration.p99
-
-                              Unique tags:   3
-                         Total tag values:   9
-                    Possible combinations: 270
-
- ──────────────────────────────────────────────────────────────────────────────────────────────
-┌──────────────────────────────────────────────────────────────────────────────────────────────┐
-│ Schema Analysis Results:                                                                     │
-│                                        SUMMARY                                               │
-└──────────────────────────────────────────────────────────────────────────────────────────────┘
-
-                     Total unique metrics:  16
-Total possible custom metric combinations: 342
-```
+
+![output](./docs/img/dss-analyze.png)
 
 This analysis shows that your schema will generate **342 custom metrics** across **16 unique metric names**. Understanding this before deployment helps prevent unexpected Datadog billing surprises.
 
@@ -318,6 +267,9 @@ tag :user_tier, values: %w[free premium enterprise]
 tag :user_cohort, values: %w[new_user returning_user power_user]
 ```
 
+> [!CAUTION]
+> Be mindful of the number of tags and tag values your schema allows.
+
 ### Schema Validation
 
 Always validate your schema before deployment:
@@ -333,67 +285,207 @@ end
 
 ## Integration Examples
 
-### Rails Integration
+### Sidekiq Job Monitoring
+
+Imagine that we are building a Rails application, and we prefer to create our own tracking of the jobs performed, failed, succeeded, as well as their duration. 
+
+> [!TIP] 
+> A very similar approach would work for tracking eg. requests coming to the `ApplicationController` subclasses.
+
+First, let's initialize the schema from a file (we'll dive into the schema a bit later):
 
 ```ruby
 # config/initializers/datadog_statsd.rb
-schema = Datadog::Statsd::Schema.load_file(Rails.root.join('config/metrics_schema.rb'))
+SIDEKIQ_SCHEMA = Datadog::Statsd::Schema.load_file(Rails.root.join('config/metrics/sidekiq.rb'))
 
 Datadog::Statsd::Schema.configure do |config|
   config.statsd = Datadog::Statsd.new
-  config.schema = schema
+  config.schema = SIDEKIQ_SCHEMA
   config.tags = {
     environment: Rails.env,
-    service: 'my-rails-app'
+    service: 'my-rails-app',
+    version: ENV['DEPLOY_SHA']
   }
 end
-
-# app/controllers/application_controller.rb
-class ApplicationController < ActionController::Base
-  before_action :setup_metrics
-
-  private
-
-  def setup_metrics
-    @metrics = Datadog::Statsd::Emitter.new(
-      validation_mode: Rails.env.production? ? :disabled : :warn
-    )
-  end
-end
 ```
 
-### Background Job Monitoring
+#### Adding Statsd Tracking to a Worker
+
+In this example, a job monitors itself by submitting a relevant statsd metrics:
 
 ```ruby
 class OrderProcessingJob
+  QUEUE = 'orders'.freeze
+
+  include Sidekiq::Job
+  sidekiq_options queue: QUEUE
+
   def perform(order_id)
-    metrics = Datadog::Statsd::Emitter.new
-    
     start_time = Time.current
     
     begin
       process_order(order_id)
-      metrics.increment('jobs.order_processing.success', tags: { queue: 'orders' })
+      emitter.increment('order_processing.success')
     rescue => error
-      metrics.increment('jobs.order_processing.failure', 
-                       tags: { queue: 'orders', error_type: error.class.name })
+      emitter.increment(
+        'order_processing.failure', 
+        tags: { error_type: error.class.name }
+      )
       raise
     ensure
       duration = Time.current - start_time
-      metrics.distribution('jobs.order_processing.duration', duration * 1000,
-                          tags: { queue: 'orders' })
+      emitter.distribution(
+        'jobs.order_processing.duration', 
+        duration * 1000
+      )
+    end
+  end
+
+  # Create an instance of an Emitter equipped with our metric
+  # prefix and the tags.
+  def emitter
+    @emitter ||= Datadog::Statsd::Emitter.new(
+      self, 
+      metric: 'job', 
+      tags: { queue: QUEUE }
+    )
+  end
+end
+```
+
+The above Emitter will generate the following metrics: 
+
+ * `job.order_processing.success` (counter)
+ * `job.order_processing.failure` (counter)
+ * `job.order_processing.duration.count`
+ * `job.order_processing.duration.min`
+ * `job.order_processing.duration.max`
+ * `job.order_processing.duration.sum`
+ * `job.order_processing.duration.avg`
+
+
+However, you can see that doing this in each job is not practical. Therefore the first question that should be on our mind is — how do we make it so that this behavior would automatically apply to any Job we create?
+
+#### Tracking All Sidekiq Workers At Once
+
+The qustion postulated above is — can we come up with a class design patter that allows us to write this code once and forget about it?
+
+**Let's take Ruby's metaprogramming for a spin.**
+
+One of the most flexible methods to add functionality to all jobs is to create a module that the job classes include *instead of* the implementation-specific `Sidekiq::Job`.
+
+So let's create our own module, let's call it `BackgroundWorker`, that we'll include into our classes instead. Once created, we'd like for our job classes to look like this:
+
+```ruby
+class OrderProcessingJob
+  include BackgroundWorker
+  sidekiq_options queue: 'orders'
+  
+  def perform(order_id)
+    # perform the work for the given order ID
+  end
+end
+```
+
+So our module, when included, should:
+
+* include `Sidekiq::Job` as well
+* define the `emitter` method so that it's available to all Job instances
+* wrap `perform` method in the exception handling block that emits corresponding metrics as in our example before.
+
+The only tricky part here is the last one: wrapping `perform` method in some shared code. This used to require "monkey patching", but no more. These days Ruby gives us an all-powerful `prepend` method that does exactly what we need. 
+
+Final adjustment we'd like to make is the metric naming.
+
+While the metrics such as:
+
+ * `job.order_processing.success` (counter)
+ * `job.order_processing.failure` (counter)
+
+are easy to understand, the question begs: do we really need to insert the job's class name into the metric name? Or — is there a better way?
+
+The truth is — there is! Why create 7 unique metrics **per job** when we can simply submit the same metrics for all jobs, tagged with our job's class name as an "emitter" source?
+
+#### Module for including into Backround Worker
+
+So, without furether ado, here we go:
+
+```ruby
+module BackgroundWorker
+  class << self
+    def included(klass)
+      klass.include(Sidekiq::Job)
+      klass.prepend(InstanceMethods)
+    end
+
+    module InstanceMethods
+      def perform(...)
+        start_time = Time.current
+        tags = {}
+        error = nil
+
+        begin
+          super(...)
+          emitter.increment("success")
+        rescue => error
+          tags.merge!({ error_type: error.class.name } )
+          emitter.increment("failure", tags:)
+          raise
+        ensure
+          duration = Time.current - start_time
+          emitter.distribution(
+            "duration", 
+            duration * 1000,
+            tags:
+          )
+        end
+      end
+
+      def emitter
+        @emitter ||= Datadog::Statsd::Emitter.new(
+          metric: 'sidekiq.job', 
+          tags: { 
+            queue: sidekiq_options[:queue], 
+            job: self.class.name 
+          }
+        )
+      end
     end
   end
 end
 ```
 
+> [!TIP]
+> In a nutshell, we created a reusable module that, upon being included into any Job class, provides  reliable tracking of job successes and failures, as well as the duration. The duration can be graphed for all successful jobs by ensuring the tag `error_type` does not exist. 
+
+So, the above strategy will generate the following metrics **FOR ALL** jobs:
+
+The above Emitter will generate the following metrics: 
+
+ * `sidekiq.job.success` (counter)
+ * `sidekiq.job.failure` (counter)
+ * `sidekiq.job.duration.count`
+ * `sidekiq.job.duration.min`
+ * `sidekiq.job.duration.max`
+ * `sidekiq.job.duration.sum`
+ * `sidekiq.job.duration.avg`
+
+that will be tagged with the following tags:
+
+* `queue:       ... `
+* `job:         { 'OrderProcessingJob' | ... }`
+* `environment: { "production" | "staging" | "development" }`
+* `service:     'my-rails-app'`
+* `version:     { "git-sha" }`
+
 ## Development
 
 After checking out the repo, run:
 
 ```bash
-bin/setup     # Install dependencies
-bundle exec rake spec  # Run tests
+bin/setup              # Install dependencies
+bundle exec rspec      # Run Specs
+bundle exec rubocop    # Run Rubocop
 ```
 
 To install this gem onto your local machine:

data/Rakefile

@@ -2,6 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 require "timeout"
 
 def shell(*args)
@@ -26,4 +27,7 @@ task build: :permissions
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+RuboCop::RakeTask.new(:rubocop)
+
+# Define the default task to include both
+task default: %i[spec rubocop]

data/examples/schema/example_marathon.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# vim: ft=ruby
+
 namespace "marathon" do
   tags do
     tag :course, values: %w[sf-marathon new-york austin]

data/examples/schema/web_schema.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# vim: ft=ruby
+
+namespace :web do
+  tags do
+    tag :environment, values: %w[production staging development]
+    tag :service, values: %w[api web worker]
+    tag :region, values: %w[us-east-1 us-west-2 eu-west-1]
+  end
+
+  namespace :requests do
+    metrics do
+      counter :total do
+        description "Total HTTP requests"
+        tags required: %i[environment service], allowed: %i[region]
+      end
+
+      distribution :duration do
+        description "Request processing time in milliseconds"
+        inherit_tags "web.requests.total"
+      end
+    end
+  end
+
+  metrics do
+    gauge :memory_usage do
+      description "Memory usage in bytes"
+      tags required: %i[environment], allowed: %i[service]
+    end
+  end
+end

data/lib/datadog/statsd/schema/analyzer.rb

@@ -2,6 +2,10 @@
 
 require "stringio"
 require "colored2"
+require "forwardable"
+require "json"
+require "yaml"
+
 module Datadog
   class Statsd
     module Schema
@@ -49,41 +53,66 @@ module Datadog
           histogram: %w[count min max sum avg]
         }.freeze
 
-        attr_reader :schemas, :stdout, :stderr, :color
+        attr_reader :schemas, :stdout, :stderr, :color, :format, :analysis_result
+
+        SUPPORTED_FORMATS = %i[text json yaml].freeze
 
         # Initialize analyzer with schema(s)
         # @param schemas [Datadog::Statsd::Schema::Namespace, Array<Datadog::Statsd::Schema::Namespace>]
         #   Single schema or array of schemas to analyze
-        def initialize(schemas, stdout: $stdout, stderr: $stderr, color: true)
+        def initialize(
+          schemas,
+          stdout: $stdout,
+          stderr: $stderr,
+          color: true,
+          format: SUPPORTED_FORMATS.first
+        )
           @schemas = Array(schemas)
           @stdout = stdout
           @stderr = stderr
           @color = color
+          @format = format.to_sym
+
+          raise ArgumentError, "Unsupported format: #{format}. Supported formats are: #{SUPPORTED_FORMATS.join(", ")}" unless SUPPORTED_FORMATS.include?(format)
+
           if color
             Colored2.enable!
           else
             Colored2.disable!
           end
+
+          @analysis_result = analyze
         end
 
         # Perform comprehensive analysis of the schemas
         # @return [AnalysisResult] Complete analysis results
         def analyze
           all_metrics = collect_all_metrics
-          metrics_analysis = analyze_metrics(all_metrics)
-
-          total_unique_metrics = metrics_analysis.sum { |analysis| analysis.expanded_names.size }
-          total_possible_custom_metrics = metrics_analysis.sum(&:total_combinations)
+          metrics_analysis = analyze_metrics(all_metrics).map(&:to_h)
 
-          stdout.puts format_analysis_output(metrics_analysis, total_unique_metrics, total_possible_custom_metrics)
+          total_unique_metrics = metrics_analysis.sum { |analysis| analysis[:expanded_names].size }
+          total_possible_custom_metrics = metrics_analysis.sum { |e| e[:total_combinations] }
 
           AnalysisResult.new(
-            total_unique_metrics: total_unique_metrics,
-            metrics_analysis: metrics_analysis,
-            total_possible_custom_metrics: total_possible_custom_metrics
+            total_unique_metrics:,
+            metrics_analysis:,
+            total_possible_custom_metrics:
           )
         end
 
+        def render
+          case format
+          when :text
+            TextFormatter.new(stdout:, stderr:, color:, analysis_result:).render
+          when :json
+            JSONFormatter.new(stdout:, stderr:, color:, analysis_result:).render
+          when :yaml
+            YAMLFormatter.new(stdout:, stderr:, color:, analysis_result:).render
+          else
+            raise ArgumentError, "Unsupported format: #{format}. Supported formats are: #{SUPPORTED_FORMATS.join(", ")}"
+          end
+        end
+
         private
 
         # Collect all metrics from all schemas with their context
@@ -327,69 +356,120 @@ module Datadog
           end
         end
 
-        # Format the analysis output for display
-        # @param metrics_analysis [Array<MetricAnalysis>] All metric analyses
-        # @param total_unique_metrics [Integer] Total unique metrics
-        # @param total_possible_custom_metrics [Integer] Total possible combinations
-        # @return [String] Formatted output
-        def format_analysis_output(
-          metrics_analysis,
-          total_unique_metrics,
-          total_possible_custom_metrics
-        )
-          output = StringIO.new
+        # ——————————————————————————————————————————————————————————————————————————————————————————————————————————————-
+        # Formatter classes
+        # ——————————————————————————————————————————————————————————————————————————————————————————————————————————————-
+        class BaseFormatter
+          attr_reader :stdout, :stderr, :color,
+                      :analysis_result,
+                      :total_unique_metrics,
+                      :metrics_analysis,
+                      :total_possible_custom_metrics
+
+          def initialize(stdout:, stderr:, color:, analysis_result:)
+            @stdout = stdout
+            @stderr = stderr
+            @color = color
+            @analysis_result = analysis_result.to_h.transform_values { |v| v.is_a?(Data) ? v.to_h : v }
+            @total_unique_metrics = @analysis_result[:total_unique_metrics]
+            @metrics_analysis = @analysis_result[:metrics_analysis]
+            @total_possible_custom_metrics = @analysis_result[:total_possible_custom_metrics]
+          end
 
-          format_metric_analysis_header(output)
-          metrics_analysis.each do |analysis|
-            output.puts
-            format_metric_analysis(output, analysis)
-            line(output, placement: :flat)
+          def render
+            raise NotImplementedError, "Subclasses must implement this method"
           end
-          summary(output, total_unique_metrics, total_possible_custom_metrics)
-          output.string
         end
 
-        def line(output, placement: :top)
-          if placement == :top
-            output.puts "┌──────────────────────────────────────────────────────────────────────────────────────────────┐".white.on.blue
-          elsif placement == :bottom
-            output.puts "└──────────────────────────────────────────────────────────────────────────────────────────────┘".white.on.blue
-          elsif placement == :middle
-            output.puts "├──────────────────────────────────────────────────────────────────────────────────────────────┤".white.on.blue
-          elsif placement == :flat
-            output.puts " ──────────────────────────────────────────────────────────────────────────────────────────────".white.bold
+        class TextFormatter < BaseFormatter
+          attr_reader :output
+
+          def render
+            @output = StringIO.new
+            format_analysis_output
+            @output.string
           end
-        end
 
-        def summary(output, total_unique_metrics, total_possible_custom_metrics)
-          line(output)
-          output.puts "│ Schema Analysis Results:                                                                     │".yellow.bold.on.blue
-          output.puts "│                                        SUMMARY                                               │".white.on.blue
-          line(output, placement: :bottom)
-          output.puts
-          output.puts "                     Total unique metrics: #{("%3d" % total_unique_metrics).bold.green}"
-          output.puts "Total possible custom metric combinations: #{("%3d" % total_possible_custom_metrics).bold.green}"
-          output.puts
+          private
+
+          # Format the analysis output for display
+          def format_analysis_output
+            format_metric_analysis_header(output)
+
+            analysis_result[:metrics_analysis].each do |analysis|
+              output.puts
+              format_metric_analysis(output, analysis)
+              line(output, placement: :flat)
+            end
+
+            summary(
+              output,
+              analysis_result[:total_unique_metrics],
+              analysis_result[:total_possible_custom_metrics]
+            )
+            output.string
+          end
+
+          def line(output, placement: :top)
+            if placement == :top
+              output.puts "┌──────────────────────────────────────────────────────────────────────────────────────────────┐".white.on.blue
+            elsif placement == :bottom
+              output.puts "└──────────────────────────────────────────────────────────────────────────────────────────────┘".white.on.blue
+            elsif placement == :middle
+              output.puts "├──────────────────────────────────────────────────────────────────────────────────────────────┤".white.on.blue
+            elsif placement == :flat
+              output.puts " ──────────────────────────────────────────────────────────────────────────────────────────────".white.bold
+            end
+          end
+
+          def summary(output, total_unique_metrics, total_possible_custom_metrics)
+            line(output)
+            output.puts "│ Schema Analysis Results:                                                                     │".yellow.bold.on.blue
+            output.puts "│                                        SUMMARY                                               │".white.on.blue
+            line(output, placement: :bottom)
+            output.puts
+            output.puts "                     Total unique metrics: #{("%3d" % total_unique_metrics).bold.green}"
+            output.puts "Total possible custom metric combinations: #{("%3d" % total_possible_custom_metrics).bold.green}"
+            output.puts
+          end
+
+          def format_metric_analysis_header(output)
+            line(output)
+            output.puts "│ Detailed Metric Analysis:                                                                    │".white.on.blue
+            line(output, placement: :bottom)
+          end
+
+          def format_metric_analysis(output, analysis)
+            output.puts "  • #{analysis[:metric_type].to_s.cyan}('#{analysis[:metric_name].yellow.bold}')"
+            if analysis[:expanded_names].size > 1
+              output.puts  "    Expanded names:"
+              output.print "      • ".yellow
+              output.puts analysis[:expanded_names].join("\n      • ").yellow
+            end
+            output.puts
+            output.puts "                              Unique tags: #{("%3d" % analysis[:unique_tags]).bold.green}"
+            output.puts "                         Total tag values: #{("%3d" % analysis[:unique_tag_values]).bold.green}"
+            output.puts "                    Possible combinations: #{("%3d" % analysis[:total_combinations]).bold.green}"
+            output.puts
+          end
         end
 
-        def format_metric_analysis_header(output)
-          line(output)
-          output.puts "│ Detailed Metric Analysis:                                                                    │".white.on.blue
-          line(output, placement: :bottom)
+        # ——————————————————————————————————————————————————————————————————————————————————————————————————————————————-
+        # JSON Formatter classes
+        # ——————————————————————————————————————————————————————————————————————————————————————————————————————————————-
+        class JSONFormatter < BaseFormatter
+          def render
+            JSON.pretty_generate(analysis_result.to_h)
+          end
         end
 
-        def format_metric_analysis(output, analysis)
-          output.puts "  • #{analysis.metric_type.to_s.cyan}('#{analysis.metric_name.yellow.bold}')"
-          if analysis.expanded_names.size > 1
-            output.puts  "    Expanded names:"
-            output.print "      • ".yellow
-            output.puts analysis.expanded_names.join("\n      • ").yellow
+        # ——————————————————————————————————————————————————————————————————————————————————————————————————————————————-
+        # YAML Formatter classes
+        # ——————————————————————————————————————————————————————————————————————————————————————————————————————————————-
+        class YAMLFormatter < BaseFormatter
+          def render
+            YAML.dump(analysis_result.to_h)
           end
-          output.puts
-          output.puts "                              Unique tags: #{("%3d" % analysis.unique_tags).bold.green}"
-          output.puts "                         Total tag values: #{("%3d" % analysis.unique_tag_values).bold.green}"
-          output.puts "                    Possible combinations: #{("%3d" % analysis.total_combinations).bold.green}"
-          output.puts
         end
       end
     end

data/lib/datadog/statsd/schema/commands/analyze.rb

@@ -18,7 +18,8 @@ module Datadog
           desc "Analyze a schema file for metrics and validation"
 
           option :file, aliases: %w[-f], type: :string, required: true, desc: "Path to the schema file to analyze"
-          option :color, aliases: %w[-c], type: :boolean, required: false, desc: "Enable/Disable color output"
+          option :color, aliases: %w[-c], type: :boolean, required: false, desc: "Enable/Disable color output", default: true
+          option :format, aliases: %w[-o], type: :string, required: false, desc: "Output format, supports: json, yaml, text", default: :text
 
           # @description Analyze a schema file for metrics and validation
           # @param options [Hash] The options for the command
@@ -34,16 +35,26 @@ module Datadog
               exit 1
             end
 
-            warn "Analyzing schema file: #{file}, color: #{options[:color]}"
+            warn "Analyzing Schema File:"
+            warn " • file   #{file.green}"
+            warn " • color: #{(options[:color] ? "enabled" : "disabled").yellow}"
+            warn " • formar #{options[:format].to_s.red}"
             @schema = ::Datadog::Statsd::Schema.load_file(file)
             ::Datadog::Statsd::Schema::Analyzer.new([@schema],
+                                                    format: (options[:format] || :text).to_sym,
                                                     stdout: self.class.stdout,
                                                     stderr: self.class.stderr,
-                                                    color: options[:color]).analyze
+                                                    color: options[:color]).tap do |analyzer|
+                                                      puts analyzer.render
+                                                    end.analyze
           end
 
-          def warn(message)
-            self.class.stderr.puts message
+          def warn(...)
+            self.class.stderr.puts(...)
+          end
+
+          def puts(...)
+            self.class.stdout.puts(...)
           end
         end
       end

data/lib/datadog/statsd/schema/version.rb

@@ -8,7 +8,7 @@ module Datadog
     module Schema
       # Current version of the datadog-statsd-schema gem
       # @return [String] The semantic version string
-      VERSION = "0.2.0"
+      VERSION = "0.2.1"
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: datadog-statsd-schema
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Konstantin Gredeskoul
 bindir: exe
 cert_chain: []
-date: 2025-06-07 00:00:00.000000000 Z
+date: 2025-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -171,8 +171,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/img/dss-analyze.png
 - examples/README.md
 - examples/schema/example_marathon.rb
+- examples/schema/web_schema.rb
 - examples/schema_emitter.png
 - examples/schema_emitter.rb
 - examples/shared.rb