Adds handling for malformed metrics (#337)

* Adds handling for malformed metrics

In the Ruby GraphQL gem we have observed some interesting behavior where collectors appear not to be registered, which causes the code from that gem to error:

```ruby

@trace.prometheus_client.send_json(
  # [!!] No name here
  type: @trace.prometheus_collector_type,
  duration: duration,
  platform_key: event_name,
  key: keyword
)
```

On one hand this appears to be a malformed request body as-is, and the tests do not appear to test the integration in validating this behavior.

Given that, that brings up a potential edge case which may warrant some discussion: What should PrometheusExporter do in a case where it gets a malformed metric that does not have a name? Should it give
an error? Right now what it returns is this:

```ruby
```

...which does not give clear tracability into the cause and potential resolutions.

The opinion of this PR, at least, is to allow it to gracefully fail when a metric cannot be registered but I am not convinced that this is the correct
behavior in this scenario and would defer to the folks working on the project as to what makes the most sense here.

* Fix logger calls in Collector by passing WebServer logger

- Add logger parameter to Collector#initialize with default fallback
- Pass WebServer's @logger to Collector during initialization
- Add tests for logger functionality and malformed metric warnings

Author: baweaver

lib/prometheus_exporter/server/collector.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require "logger"
+
 module PrometheusExporter::Server
   class Collector < CollectorBase
-    def initialize(json_serializer: nil)
+    attr_reader :logger
+
+    def initialize(json_serializer: nil, logger: Logger.new(STDERR))
+      @logger = logger
       @process_metrics = []
       @metrics = {}
       @mutex = Mutex.new
@@ -40,6 +45,8 @@ def process_hash(obj)
           metric = @metrics[obj["name"]]
           metric = register_metric_unsafe(obj) if !metric
 
+          next unless metric
+
           keys = obj["keys"] || {}
           keys = obj["custom_labels"].merge(keys) if obj["custom_labels"]
 
@@ -74,6 +81,11 @@ def register_metric_unsafe(obj)
       help = obj["help"]
       opts = symbolize_keys(obj["opts"] || {})
 
+      if !name
+        logger.warn "failed to register metric due to empty name #{obj}"
+        return
+      end
+
       metric =
         case obj["type"]
         when "gauge"
@@ -89,7 +101,7 @@ def register_metric_unsafe(obj)
       if metric
         @metrics[name] = metric
       else
-        STDERR.puts "failed to register metric #{obj}"
+        logger.warn "failed to register metric #{obj}"
       end
     end
 

lib/prometheus_exporter/server/web_server.rb

@@ -12,7 +12,6 @@ class WebServer
     def initialize(opts)
       @port = opts[:port] || PrometheusExporter::DEFAULT_PORT
       @bind = opts[:bind] || PrometheusExporter::DEFAULT_BIND_ADDRESS
-      @collector = opts[:collector] || Collector.new
       @timeout = opts[:timeout] || PrometheusExporter::DEFAULT_TIMEOUT
       @verbose = opts[:verbose] || false
       @auth = opts[:auth]
@@ -61,6 +60,8 @@ def initialize(opts)
         @bind = nil
       end
 
+      @collector = opts[:collector] || Collector.new(logger: @logger)
+
       @server =
         WEBrick::HTTPServer.new(
           Port: @port,

test/server/collector_test.rb

@@ -100,6 +100,45 @@ def test_register_metric
     assert_equal(text, collector.prometheus_metrics_text)
   end
 
+  def test_malformed_metric_without_name_or_action
+    collector = PrometheusExporter::Server::Collector.new
+
+    json = {
+      type: :gauge,
+      keys: {
+        key1: "test1",
+      },
+      value: 1,
+    }.to_json
+
+    collector.process(json)
+
+    assert_equal("", collector.prometheus_metrics_text)
+  end
+
+  def test_default_logger
+    collector = PrometheusExporter::Server::Collector.new
+    assert_instance_of(Logger, collector.logger)
+  end
+
+  def test_custom_logger
+    logs = StringIO.new
+    custom_logger = Logger.new(logs)
+    collector = PrometheusExporter::Server::Collector.new(logger: custom_logger)
+    
+    assert_equal(custom_logger, collector.logger)
+  end
+
+  def test_logger_warns_on_malformed_metric
+    logs = StringIO.new
+    collector = PrometheusExporter::Server::Collector.new(logger: Logger.new(logs))
+
+    json = { type: :gauge, keys: { key1: "test1" }, value: 1 }.to_json
+    collector.process(json)
+
+    assert_includes(logs.string, "failed to register metric due to empty name")
+  end
+
   def test_it_can_increment_gauge_when_specified
     name = "test_name"
     help = "test_help"