toggly 0.3.0 → 0.5.0

data/lib/toggly/definitions_provider.rb

@@ -14,6 +14,9 @@ end
 module Toggly
   # Provider for fetching feature definitions from Toggly API.
   class DefinitionsProvider
+    # Result of one HTTP definitions fetch with cache telemetry outcome.
+    FetchResult = Struct.new(:definitions, :cache_outcome, keyword_init: true)
+
     # Fallback HTTP refresh interval when WebSocket is connected (20 minutes)
     FALLBACK_REFRESH_INTERVAL = 20 * 60
 
@@ -32,6 +35,7 @@ module Toggly
       @on_definitions_updated = on_definitions_updated
       @etag = nil
       @last_modified = nil
+      @last_ts = 0
 
       # WebSocket state
       @ws = nil
@@ -44,11 +48,11 @@ module Toggly
     # Fetch definitions from the API
     #
     # @param force [Boolean] Force fetch even if cached
-    # @return [Hash, nil] Hash of definitions, or nil if not modified
+    # @return [FetchResult] definitions (Hash or nil) plus :hit / :miss outcome
     # @raise [NetworkError] On network failures
     # @raise [DefinitionsError] On API errors
     def fetch(force: false)
-      return nil if @config.offline_mode?
+      return FetchResult.new(definitions: nil, cache_outcome: :hit) if @config.offline_mode?
 
       uri = URI.parse(@config.definitions_endpoint)
       http = build_http(uri)
@@ -60,6 +64,8 @@ module Toggly
       raise NetworkError, "Request timeout: #{e.message}"
     rescue SocketError, Errno::ECONNREFUSED => e
       raise NetworkError, "Connection failed: #{e.message}"
+    rescue NetworkError, DefinitionsError
+      raise
     rescue StandardError => e
       raise NetworkError, "Request failed: #{e.message}"
     end
@@ -68,6 +74,7 @@ module Toggly
     def reset_cache
       @etag = nil
       @last_modified = nil
+      @last_ts = 0
     end
 
     # Check whether the periodic refresh should be skipped because the
@@ -166,32 +173,81 @@ module Toggly
     end
 
     def handle_response(response)
-      case response.code.to_i
-      when 200
-        parse_definitions(response)
-      when 304
-        # Not modified
+      status = response.code.to_i
+      response_etag = response["ETag"]
+      response_lm = response["Last-Modified"]
+      kind = DefinitionCache.classify_http(
+        status,
+        @etag,
+        response_etag,
+        existing_last_modified: @last_modified,
+        response_last_modified: response_lm
+      )
+
+      case kind
+      when :not_modified
         log_debug("Definitions not modified")
-        nil
+        FetchResult.new(definitions: nil, cache_outcome: :hit)
+      when :same_revision
+        log_debug("Definitions revision matches existing (ETag or Last-Modified)")
+        store_revision_headers(response_etag, response_lm)
+        FetchResult.new(definitions: nil, cache_outcome: :hit)
+      when :new_content
+        handle_new_content(response, response_etag, response_lm)
+      when :error_status
+        handle_error_status(status, response)
+      end
+    end
+
+    def handle_new_content(response, response_etag, response_lm)
+      data = JSON.parse(response.body)
+      signed_ts = extract_signed_timestamp(data)
+      if DefinitionCache.cached_signed_timestamp?(@last_ts, signed_ts)
+        log_debug("Definitions signed timestamp is not newer than cached revision")
+        store_revision_headers(response_etag, response_lm)
+        return FetchResult.new(definitions: nil, cache_outcome: :hit)
+      end
+
+      definitions = parse_features(data)
+      store_revision_headers(response_etag, response_lm)
+      @last_ts = signed_ts if signed_ts&.positive?
+      FetchResult.new(definitions: definitions, cache_outcome: :miss)
+    rescue JSON::ParserError => e
+      raise DefinitionsError, "Failed to parse definitions: #{e.message}"
+    end
+
+    def handle_error_status(status, response)
+      case status
       when 401, 403
-        raise DefinitionsError, "Authentication failed: #{response.code}"
+        raise DefinitionsError, "Authentication failed: #{status}"
       when 404
         raise DefinitionsError, "Definitions not found (check app_key and environment)"
       else
         raise NetworkError.new(
-          "API error: #{response.code}",
-          status_code: response.code.to_i,
+          "API error: #{status}",
+          status_code: status,
           response_body: response.body
         )
       end
     end
 
-    def parse_definitions(response)
-      # Cache headers for conditional requests
-      @etag = response["ETag"]
-      @last_modified = response["Last-Modified"]
+    def store_revision_headers(etag, last_modified)
+      @etag = etag if etag && !etag.empty?
+      @last_modified = last_modified if last_modified && !last_modified.empty?
+    end
 
-      data = JSON.parse(response.body)
+    def extract_signed_timestamp(data)
+      return nil unless data.is_a?(Hash)
+
+      raw = data["timestamp"]
+      return nil if raw.nil?
+
+      Integer(raw)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def parse_features(data)
       features = if data.is_a?(Hash)
                    data["defs"] || data["features"] || data
                  else
@@ -209,8 +265,6 @@ module Toggly
       else
         raise DefinitionsError, "Invalid definitions format"
       end
-    rescue JSON::ParserError => e
-      raise DefinitionsError, "Failed to parse definitions: #{e.message}"
     end
 
     def build_websocket_url

data/lib/toggly/telemetry/grpc_clients.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Toggly
+  module Telemetry
+    # Optional gRPC transport helpers for usage and metrics telemetry.
+    module GrpcClients
+      DEFAULT_METRICS_BASE_URL = "https://app.toggly.io/"
+      DEFAULT_TELEMETRY_FLUSH_SECONDS = 60.0
+
+      # HTTP/2 metadata is case-insensitive; .NET/Go/Node send ``UA``.
+      # The Ruby grpc gem lowercases keys, so we send ``ua`` with the same
+      # user-agent semantics.
+      GRPC_USER_AGENT_METADATA_KEY = "ua"
+
+      module_function
+
+      # FNV-1a 32-bit as signed int32 (UTF-8 bytes; matches Go/Node/Python).
+      #
+      # @param identity [String]
+      # @return [Integer] signed int32
+      def hash_identity(identity)
+        h = 2_166_136_261
+        identity.to_s.encode("UTF-8").bytes.each do |byte|
+          h ^= byte
+          h = (h * 16_777_619) & 0xFFFFFFFF
+        end
+        h > 0x7FFFFFFF ? h - 0x100000000 : h
+      end
+
+      # @param time [Time, nil]
+      # @return [Hash{Symbol => Integer}] protobuf Timestamp shape
+      def to_protobuf_timestamp(time = nil)
+        t = time || Time.now.utc
+        t = t.utc
+        ms = (t.to_f * 1000).to_i
+        {
+          seconds: ms / 1000,
+          nanos: (ms % 1000) * 1_000_000
+        }
+      end
+
+      # Build a protobuf Timestamp from a batcher hash. Nested message fields are
+      # nil until assigned — callers must assign the returned object, not mutate
+      # ``msg.time.seconds``.
+      #
+      # @param timestamp_hash [Hash, nil]
+      # @return [Google::Protobuf::Timestamp, nil]
+      def build_timestamp(timestamp_hash)
+        return nil unless timestamp_hash.is_a?(Hash)
+
+        require "google/protobuf/timestamp_pb"
+        Google::Protobuf::Timestamp.new(
+          seconds: timestamp_hash[:seconds].to_i,
+          nanos: timestamp_hash[:nanos].to_i
+        )
+      end
+
+      # @param base_url [String]
+      # @return [String] host:port for a gRPC channel
+      def grpc_target(base_url)
+        raw = base_url.to_s.strip
+        raw = "https://#{raw}" unless raw.include?("://")
+        uri = begin
+          URI.parse(raw)
+        rescue URI::InvalidURIError
+          nil
+        end
+        host = if uri
+                 uri.host || uri.path
+               else
+                 raw.sub(%r{\Ahttps?://}i, "").delete_suffix("/")
+               end
+        host = host.to_s.delete_suffix("/")
+        host = "app.toggly.io:443" if host.empty?
+        host = "#{host}:443" unless host.include?(":")
+        host
+      end
+
+      # @param override [String, nil]
+      # @return [String]
+      def resolve_user_agent(override = nil)
+        override || "toggly-ruby/#{Toggly::VERSION}"
+      end
+
+      # @return [Boolean]
+      def grpc_available?
+        return @grpc_available unless @grpc_available.nil?
+
+        require "grpc"
+        require_relative "pb/usage_services_pb"
+        require_relative "pb/metrics_services_pb"
+        @grpc_available = true
+      rescue LoadError
+        @grpc_available = false
+      end
+
+      # Reset cached availability (tests only).
+      def reset_grpc_available!
+        @grpc_available = nil
+      end
+
+      # Convert a batcher dict into Usage.FeatureStat.
+      #
+      # @param payload [Hash]
+      # @return [Toggly::Telemetry::Pb::Usage::FeatureStat]
+      def feature_stat_from_payload(payload)
+        NativeUsageClient.feature_stat_from_payload(payload)
+      end
+
+      # Convert a batcher dict into Metrics.MetricStat.
+      #
+      # @param payload [Hash]
+      # @return [Toggly::Telemetry::Pb::Metrics::MetricStat]
+      def metric_stat_from_payload(payload)
+        NativeMetricsClient.metric_stat_from_payload(payload)
+      end
+
+      # @param metrics_base_url [String]
+      # @param user_agent [String, nil]
+      # @param timeout [Numeric]
+      # @return [Clients, nil]
+      def create(metrics_base_url, user_agent: nil, timeout: 10.0)
+        return nil unless grpc_available?
+
+        require "grpc"
+
+        target = grpc_target(metrics_base_url)
+        channel = GRPC::Core::Channel.new(target, {}, GRPC::Core::ChannelCredentials.new)
+        shared = SharedChannel.new(channel)
+        ua = resolve_user_agent(user_agent)
+        default_meta = { GRPC_USER_AGENT_METADATA_KEY => ua }
+
+        usage_stub = Pb::Usage::Usage::Stub.new(target, GRPC::Core::ChannelCredentials.new,
+                                                channel_override: channel)
+        metrics_stub = Pb::Metrics::Metrics::Stub.new(target, GRPC::Core::ChannelCredentials.new,
+                                                      channel_override: channel)
+
+        Clients.new(
+          usage: NativeUsageClient.new(usage_stub, shared, default_meta, timeout),
+          metrics: NativeMetricsClient.new(metrics_stub, shared, default_meta, timeout)
+        )
+      end
+
+      # Paired usage + metrics clients.
+      Clients = Struct.new(:usage, :metrics, keyword_init: true)
+
+      # Shared channel closer (close once).
+      class SharedChannel
+        def initialize(channel)
+          @channel = channel
+          @closed = false
+          @mutex = Mutex.new
+        end
+
+        def close
+          @mutex.synchronize do
+            return if @closed
+
+            @closed = true
+            @channel.close
+          end
+        end
+      end
+
+      # Converts batcher hashes into Usage.FeatureStat and sends via stub.
+      class NativeUsageClient
+        def initialize(stub, shared, default_metadata, timeout)
+          @stub = stub
+          @shared = shared
+          @default_metadata = default_metadata.transform_keys(&:to_s)
+          @timeout = timeout
+        end
+
+        def send_stats(request, metadata: nil)
+          meta = @default_metadata.merge((metadata || {}).transform_keys(&:to_s))
+          msg = self.class.feature_stat_from_payload(request)
+          @stub.send_stats(msg, metadata: meta.to_a, deadline: Time.now + @timeout)
+        end
+
+        def close
+          @shared.close
+        end
+
+        # @param payload [Hash]
+        # @return [Toggly::Telemetry::Pb::Usage::FeatureStat]
+        def self.feature_stat_from_payload(payload)
+          require_relative "pb/usage_pb"
+
+          msg = Pb::Usage::FeatureStat.new(
+            appKey: payload[:appKey].to_s,
+            environment: payload[:environment].to_s,
+            totalUniqueUsers: payload[:totalUniqueUsers].to_i,
+            uniqueUserHashes: Array(payload[:uniqueUserHashes]).map(&:to_i)
+          )
+          apply_feature_stat_metadata(msg, payload)
+          Array(payload[:stats]).each do |stat|
+            next unless stat.is_a?(Hash)
+
+            msg.stats << stat_message_from_hash(stat)
+          end
+          msg
+        end
+
+        def self.apply_feature_stat_metadata(msg, payload)
+          timestamp = GrpcClients.build_timestamp(payload[:time])
+          msg.time = timestamp if timestamp
+          msg.instanceName = payload[:instanceName].to_s if payload[:instanceName]
+          msg.appVersion = payload[:appVersion].to_s if payload[:appVersion]
+          process_start = GrpcClients.build_timestamp(payload[:processStartTime])
+          msg.processStartTime = process_start if process_start
+          msg.definitionCacheHits = payload[:definitionCacheHits].to_i if payload[:definitionCacheHits]
+          msg.definitionCacheMisses = payload[:definitionCacheMisses].to_i if payload[:definitionCacheMisses]
+        end
+        private_class_method :apply_feature_stat_metadata
+
+        def self.stat_message_from_hash(stat)
+          sm = Pb::Usage::StatMessage.new(
+            feature: stat[:feature].to_s,
+            uniqueContextIdentifierEnabledCount: stat[:uniqueContextIdentifierEnabledCount].to_i,
+            uniqueContextIdentifierDisabledCount: stat[:uniqueContextIdentifierDisabledCount].to_i,
+            uniqueUsersUsedCount: stat[:uniqueUsersUsedCount].to_i,
+            uniqueUserHashes: Array(stat[:uniqueUserHashes]).map(&:to_i),
+            uniqueViewedUserHashes: Array(stat[:uniqueViewedUserHashes]).map(&:to_i)
+          )
+          (stat[:variantStats] || {}).each do |name, vs|
+            next unless vs.is_a?(Hash)
+
+            sm.variantStats[name.to_s] = Pb::Usage::VariantStats.new(
+              checkCount: vs[:checkCount].to_i,
+              requestCount: vs[:requestCount].to_i,
+              usedCount: vs[:usedCount].to_i,
+              viewedCount: vs[:viewedCount].to_i
+            )
+          end
+          sm
+        end
+        private_class_method :stat_message_from_hash
+      end
+
+      # Converts batcher hashes into Metrics.MetricStat and sends via stub.
+      class NativeMetricsClient
+        def initialize(stub, shared, default_metadata, timeout)
+          @stub = stub
+          @shared = shared
+          @default_metadata = default_metadata.transform_keys(&:to_s)
+          @timeout = timeout
+        end
+
+        def send_metrics(request, metadata: nil)
+          meta = @default_metadata.merge((metadata || {}).transform_keys(&:to_s))
+          msg = self.class.metric_stat_from_payload(request)
+          @stub.send_metrics(msg, metadata: meta.to_a, deadline: Time.now + @timeout)
+        end
+
+        def close
+          @shared.close
+        end
+
+        # @param payload [Hash]
+        # @return [Toggly::Telemetry::Pb::Metrics::MetricStat]
+        def self.metric_stat_from_payload(payload)
+          require_relative "pb/metrics_pb"
+
+          msg = Pb::Metrics::MetricStat.new(
+            appKey: payload[:appKey].to_s,
+            environment: payload[:environment].to_s
+          )
+          apply_metric_stat_metadata(msg, payload)
+          append_metric_stats(msg, payload[:stats])
+          append_metric_counters(msg, payload[:counters])
+          append_metric_observations(msg, payload[:observations])
+          msg
+        end
+
+        def self.apply_metric_stat_metadata(msg, payload)
+          timestamp = GrpcClients.build_timestamp(payload[:time])
+          msg.time = timestamp if timestamp
+          msg.instanceName = payload[:instanceName].to_s if payload[:instanceName]
+        end
+        private_class_method :apply_metric_stat_metadata
+
+        def self.append_metric_stats(msg, items)
+          Array(items).each do |item|
+            next unless item.is_a?(Hash)
+
+            sm = Pb::Metrics::MetricStatMessage.new(metric: item[:metric].to_s)
+            sm.feature = item[:feature].to_s if item[:feature]
+            fill_variant_values(sm, item[:variantValues])
+            msg.stats << sm
+          end
+        end
+        private_class_method :append_metric_stats
+
+        def self.append_metric_counters(msg, items)
+          Array(items).each do |item|
+            next unless item.is_a?(Hash)
+
+            cm = Pb::Metrics::MetricCounterMessage.new(metric: item[:metric].to_s)
+            cm.feature = item[:feature].to_s if item[:feature]
+            fill_variant_values(cm, item[:variantValues])
+            msg.counters << cm
+          end
+        end
+        private_class_method :append_metric_counters
+
+        def self.append_metric_observations(msg, items)
+          Array(items).each do |item|
+            next unless item.is_a?(Hash)
+
+            om = Pb::Metrics::MetricObservationMessage.new(metric: item[:metric].to_s)
+            obs_ts = GrpcClients.build_timestamp(item[:time])
+            om.time = obs_ts if obs_ts
+            om.feature = item[:feature].to_s if item[:feature]
+            fill_variant_values(om, item[:variantValues])
+            msg.observations << om
+          end
+        end
+        private_class_method :append_metric_observations
+
+        def self.fill_variant_values(target, variant_values)
+          return unless variant_values.is_a?(Hash)
+
+          variant_values.each do |name, value|
+            target.variantValues[name.to_s] = value.to_f
+          end
+        end
+        private_class_method :fill_variant_values
+      end
+    end
+  end
+end

data/lib/toggly/telemetry/metrics_batcher.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Toggly
+  module Telemetry
+    # Optional feature/variant correlation for a metric sample.
+    MetricsFeatureOptions = Struct.new(:feature, :variant, keyword_init: true)
+
+    # In-memory business metrics aggregator (Metrics.SendMetrics payload shape).
+    class MetricsBatcher
+      def initialize(app_key, environment, instance_name: nil)
+        @app_key = app_key
+        @environment = environment
+        @instance_name = instance_name
+        @measures = {}
+        @counters = {}
+        @observations = []
+        @mutex = Mutex.new
+      end
+
+      def measure(metric, value, options = nil)
+        @mutex.synchronize { add_to_map(@measures, metric, value.to_f, options) }
+      end
+
+      def increment_counter(metric, value = 1.0, options = nil)
+        @mutex.synchronize { add_to_map(@counters, metric, value.to_f, options) }
+      end
+
+      def observe(metric, value, options = nil)
+        @mutex.synchronize do
+          opts = normalize_options(options)
+          variant = opts&.variant && !opts.variant.to_s.empty? ? opts.variant.to_s : "enabled"
+          feature = opts&.feature
+          @observations << {
+            time: Time.now.utc,
+            metric: metric.to_s,
+            feature: feature,
+            variant: variant,
+            value: value.to_f
+          }
+        end
+      end
+
+      def empty?
+        @mutex.synchronize { @measures.empty? && @counters.empty? && @observations.empty? }
+      end
+
+      def build_and_reset
+        @mutex.synchronize do
+          return nil if @measures.empty? && @counters.empty? && @observations.empty?
+
+          payload = {
+            appKey: @app_key,
+            environment: @environment,
+            time: GrpcClients.to_protobuf_timestamp,
+            stats: drain_map(@measures),
+            counters: drain_map(@counters),
+            observations: drain_observations
+          }
+          payload[:instanceName] = @instance_name if @instance_name
+          payload
+        end
+      end
+
+      def self.options_from_hash(options)
+        return nil if options.nil?
+        return options if options.is_a?(MetricsFeatureOptions)
+
+        MetricsFeatureOptions.new(
+          feature: options[:feature] || options["feature"],
+          variant: options[:variant] || options["variant"]
+        )
+      end
+
+      private
+
+      def normalize_options(options)
+        self.class.options_from_hash(options)
+      end
+
+      def metric_key(metric, feature)
+        [metric.to_s, feature.to_s]
+      end
+
+      def add_to_map(store, metric, value, options)
+        opts = normalize_options(options)
+        variant = "enabled"
+        feature = nil
+        if opts
+          variant = opts.variant.to_s unless opts.variant.nil? || opts.variant.to_s.empty?
+          feature = opts.feature
+        end
+        key = metric_key(metric, feature)
+        variants = store[key] ||= {}
+        variants[variant] = variants.fetch(variant, 0.0) + value
+      end
+
+      def drain_map(store)
+        out = []
+        store.each do |(metric, feature), variants|
+          variant_values = variants.reject { |_n, v| v.zero? }
+          next if variant_values.empty?
+
+          item = { metric: metric, variantValues: variant_values }
+          item[:feature] = feature unless feature.empty?
+          out << item
+        end
+        store.clear
+        out
+      end
+
+      def drain_observations
+        observation_messages = []
+        groups = {}
+        @observations.each do |obs|
+          when_t = obs[:time]
+          group_key = "#{when_t.to_f}\0#{obs[:metric]}\0#{obs[:feature] || ""}"
+          group = groups[group_key]
+          if group.nil? || group[:variantValues].key?(obs[:variant])
+            group = new_observation_group(when_t, obs)
+            groups[group_key] = group
+            observation_messages << group
+          end
+          group[:variantValues][obs[:variant]] = obs[:value]
+        end
+        @observations = []
+        observation_messages
+      end
+
+      def new_observation_group(when_t, obs)
+        group = {
+          time: GrpcClients.to_protobuf_timestamp(when_t),
+          metric: obs[:metric],
+          variantValues: {}
+        }
+        group[:feature] = obs[:feature] if obs[:feature] && !obs[:feature].to_s.empty?
+        group
+      end
+    end
+  end
+end

data/lib/toggly/telemetry/pb/metrics_pb.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: metrics.proto
+#
+# Nested under Toggly::Telemetry::Pb to avoid top-level namespace pollution.
+# Loaded only when optional grpc/google-protobuf gems are present.
+
+require "google/protobuf"
+require "google/protobuf/timestamp_pb"
+
+descriptor_data = "\n\rmetrics.proto\x12\x07Metrics\x1a\x1fgoogle/protobuf/timestamp.proto\"\x9c\x02\n\nMetricStat\x12\x0e\n\x06\x61ppKey\x18\x01 \x01(\t\x12\x13\n\x0b\x65nvironment\x18\x02 \x01(\t\x12(\n\x04time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12)\n\x05stats\x18\x04 \x03(\x0b\x32\x1a.Metrics.MetricStatMessage\x12/\n\x08\x63ounters\x18\x05 \x03(\x0b\x32\x1d.Metrics.MetricCounterMessage\x12\x37\n\x0cobservations\x18\x06 \x03(\x0b\x32!.Metrics.MetricObservationMessage\x12\x19\n\x0cinstanceName\x18\x07 \x01(\tH\x00\x88\x01\x01\x42\x0f\n\r_instanceName\"\xbb\x02\n\x11MetricStatMessage\x12\x0e\n\x06metric\x18\x01 \x01(\t\x12\x18\n\x0c\x65nabledCount\x18\x02 \x01(\x05\x42\x02\x18\x01\x12\x19\n\rdisabledCount\x18\x03 \x01(\x05\x42\x02\x18\x01\x12\x14\n\x07\x66\x65\x61ture\x18\x04 \x01(\tH\x00\x88\x01\x01\x12\x11\n\x05value\x18\x05 \x01(\x01\x42\x02\x18\x01\x12\x1e\n\rvalueDisabled\x18\x06 \x01(\x01\x42\x02\x18\x01H\x01\x88\x01\x01\x12\x44\n\rvariantValues\x18\x07 \x03(\x0b\x32-.Metrics.MetricStatMessage.VariantValuesEntry\x1a\x34\n\x12VariantValuesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x01:\x02\x38\x01\x42\n\n\x08_featureB\x10\n\x0e_valueDisabled\"\xc1\x02\n\x14MetricCounterMessage\x12\x0e\n\x06metric\x18\x01 \x01(\t\x12\x18\n\x0c\x65nabledCount\x18\x02 \x01(\x05\x42\x02\x18\x01\x12\x19\n\rdisabledCount\x18\x03 \x01(\x05\x42\x02\x18\x01\x12\x14\n\x07\x66\x65\x61ture\x18\x04 \x01(\tH\x00\x88\x01\x01\x12\x11\n\x05value\x18\x05 \x01(\x01\x42\x02\x18\x01\x12\x1e\n\rvalueDisabled\x18\x06 \x01(\x01\x42\x02\x18\x01H\x01\x88\x01\x01\x12G\n\rvariantValues\x18\x07 \x03(\x0b\x32\x30.Metrics.MetricCounterMessage.VariantValuesEntry\x1a\x34\n\x12VariantValuesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x01:\x02\x38\x01\x42\n\n\x08_featureB\x10\n\x0e_valueDisabled\"\xf3\x02\n\x18MetricObservationMessage\x12(\n\x04time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0e\n\x06metric\x18\x02 \x01(\t\x12\x18\n\x0c\x65nabledCount\x18\x03 \x01(\x05\x42\x02\x18\x01\x12\x19\n\rdisabledCount\x18\x04 \x01(\x05\x42\x02\x18\x01\x12\x14\n\x07\x66\x65\x61ture\x18\x05 \x01(\tH\x00\x88\x01\x01\x12\x11\n\x05value\x18\x06 \x01(\x01\x42\x02\x18\x01\x12\x1e\n\rvalueDisabled\x18\x07 \x01(\x01\x42\x02\x18\x01H\x01\x88\x01\x01\x12K\n\rvariantValues\x18\x08 \x03(\x0b\x32\x34.Metrics.MetricObservationMessage.VariantValuesEntry\x1a\x34\n\x12VariantValuesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x01:\x02\x38\x01\x42\n\n\x08_featureB\x10\n\x0e_valueDisabled\"\x1d\n\x0cMetricResult\x12\r\n\x05\x63ount\x18\x01 \x01(\x05\x32\x44\n\x07Metrics\x12\x39\n\x0bSendMetrics\x12\x13.Metrics.MetricStat\x1a\x15.Metrics.MetricResultBOZMgithub.com/ops-ai/Toggly.FeatureManagement/toggly-go/toggly/metrics/metricspbb\x06proto3"
+
+pool = ::Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Toggly
+  module Telemetry
+    module Pb
+      module Metrics
+        MetricStat = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("Metrics.MetricStat").msgclass
+        MetricStatMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("Metrics.MetricStatMessage").msgclass
+        MetricCounterMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("Metrics.MetricCounterMessage").msgclass
+        MetricObservationMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("Metrics.MetricObservationMessage").msgclass
+        MetricResult = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("Metrics.MetricResult").msgclass
+      end
+    end
+  end
+end

data/lib/toggly/telemetry/pb/metrics_services_pb.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# Source: metrics.proto for package 'Metrics'
+
+require "grpc"
+require_relative "metrics_pb"
+
+module Toggly
+  module Telemetry
+    module Pb
+      module Metrics
+        module Metrics
+          class Service
+            include ::GRPC::GenericService
+
+            self.marshal_class_method = :encode
+            self.unmarshal_class_method = :decode
+            self.service_name = "Metrics.Metrics"
+
+            rpc :SendMetrics, ::Toggly::Telemetry::Pb::Metrics::MetricStat, ::Toggly::Telemetry::Pb::Metrics::MetricResult
+          end
+
+          Stub = Service.rpc_stub_class
+        end
+      end
+    end
+  end
+end