activemeasure 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 06afb38a723f4ae8cf7d834f1c5535564471c8878337aaf6d6f19dd8407dc22f
+  data.tar.gz: 864934d81291f917080982466a68a4b0e273730dabc0e3a4705003b2ae0eef29
+SHA512:
+  metadata.gz: ca4103b83f570c4f151a8d74e1d3382595cba6dc798424d794b246c76d5b5167df33d34ac77ae8ab4099873aa53322e83cf81ae5d7028242fc5a87d2b94e82b2
+  data.tar.gz: ecb1f39d86839dde6a1f13a8203dcd41c8d2db230e6ed9819a6bba88c108ecb4065128ad20f3f20aeba2c0bdd506224e694181108d10dee38fd3c7b50e33c53d

data/lib/active_measure/adapters/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveMeasure
+  module Adapters
+    class Base
+      def increment(metric, value = 1, **_options)
+        raise NotImplementedError
+      end
+
+      def decrement(metric, value = 1, **_options)
+        raise NotImplementedError
+      end
+
+      def count(metric, value, **_options)
+        raise NotImplementedError
+      end
+
+      def gauge(metric, value, **_options)
+        raise NotImplementedError
+      end
+
+      def timing(metric, value, **_options)
+        raise NotImplementedError
+      end
+
+      def time(metric, &block)
+        raise NotImplementedError
+      end
+
+      def histogram(metric, value, **_options)
+        raise NotImplementedError
+      end
+
+      def set(metric, value, **_options)
+        raise NotImplementedError
+      end
+
+      def distribution(metric, value, **_options)
+        raise NotImplementedError
+      end
+
+      private
+
+      def dispatch_metric(metric)
+        raise NotImplementedError
+      end
+
+      def connection
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/active_measure/adapters/sink.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# This is a dummy adapter that does nothing. it
+module ActiveMeasure
+  module Adapters
+    class Sink < Base
+    end
+  end
+end

data/lib/active_measure/adapters/statsd.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module ActiveMeasure
+  module Adapters
+    class Statsd < Base
+      # c - counter
+      # g - gauge
+      # h - histogram
+      # ms - measure
+      # s - set
+      # d - distribution
+      VALID_METRICS_TYPES = %i[c g h ms s d].freeze
+      def dispatch_metric(metric)
+        connection.send(metric.to_s, 0)
+      end
+
+      def initialize(options = {})
+        @host = options.fetch(:host, 'localhost')
+        @port = options.fetch(:port, 8125)
+        @client = options.fetch(:client)
+      end
+
+      def increment(metric, value = nil, tags: {}, **_options)
+        send_measure(:c, metric, value, tags)
+      end
+
+      def decrement(metric, value = nil, tags: {}, **_options)
+        send_measure(:c, metric, -value, tags)
+      end
+
+      def count(metric, value = nil, tags: {}, **_options)
+        send_measure(:c, metric, value, tags)
+      end
+
+      def gauge(metric, value = nil, tags: {}, **_options)
+        send_measure(:g, metric, value, tags)
+      end
+
+      def timing(metric, value = nil, tags: {}, **_options)
+        send_measure(:ms, metric, value, tags)
+      end
+
+      def time(metric, value = nil, tags: {}, **_options)
+        send_measure(:ms, metric, value, tags)
+      end
+
+      def histogram(metric, value = nil, tags: {}, **_options)
+        send_measure(:h, metric, value, tags)
+      end
+
+      def set(metric, value = nil, tags: {}, **_options)
+        send_measure(:s, metric, value, tags)
+      end
+
+      def distribution(metric, value = nil, tags: {}, **_options)
+        send_measure(:d, metric, value, tags)
+      end
+
+      private
+
+      def connection
+        return @connection if @connection
+
+        @connection ||= UDPSocket.new
+        @connection.bind(@host, @port)
+      end
+    end
+  end
+end

data/lib/active_measure/adapters/statsd_socket.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveMeasure
+  module Adapters
+    class StatsdSocket < Statsd
+    end
+  end
+end

data/lib/active_measure/adapters/statsd_tagged.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveMeasure
+  module Adapters
+    class StatsdTagged < Statsd
+    end
+  end
+end

data/lib/active_measure/adapters.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveMeasure
+  module Adapters
+    autoload :Base, 'active_measure/adapters/base'
+    autoload :Sink, 'active_measure/adapters/sink'
+    autoload :Statsd, 'active_measure/adapters/statsd'
+    autoload :StatsdSocket, 'active_measure/adapters/statsd_socket'
+    autoload :StatsdTagged, 'active_measure/adapters/statsd_tagged'
+    autoload :StatsdTaggedSocket, 'active_measure/adapters/statsd_tagged_socket'
+    ADAPTERS = {
+      'statsd' => 'ActiveMeasure::Adapters::Statsd',
+      'statsd_tagged' => 'ActiveMeasure::Adapters::StatsdTagged',
+      'statsd_socket' => 'ActiveMeasure::Adapters::StatsdSocket',
+      'statsd_tagged_socket' => 'ActiveMeasure::Adapters::StatsdTaggedSocket'
+    }.freeze
+
+    def self.for(adapter)
+      class_name = ADAPTERS[adapter]
+      raise("Unknown adapter: #{adapter}") unless class_name
+
+      Object.const_get(class_name)
+    end
+  end
+end

data/lib/active_measure/assertions.rb

@@ -0,0 +1,7 @@
+module ActiveMeasure
+  module Assertions
+    def assert_metric(metric, value, tags: nil)
+      raise "Not implemented"
+    end
+  end
+end

data/lib/active_measure/buffer.rb

@@ -0,0 +1,15 @@
+module ActiveMeasure
+  class Buffer < Array
+    def initialize
+      super
+    end
+
+    def <<(metric)
+      super
+    end
+
+    def flush
+      self.clear
+    end
+  end
+end

data/lib/active_measure/client.rb

@@ -0,0 +1,84 @@
+require 'singleton'
+require 'uri'
+require 'forwardable'
+
+module ActiveMeasure
+  class Client
+    extend Forwardable
+    DEFAULT_CONNECTION_STRING = 'udp://localhost:8125'
+
+    attr_reader :logger, :tags
+    attr_reader :transport, :namespace
+
+    def initialize(connection_string = nil, logger: nil, tags: {}, namespace: nil)
+      @connection_string = parse_connection_string(connection_string)
+      @connection_string[:client] = self
+      @transport = ActiveMeasure::Adapters.for(@connection_string[:adapter]).new(@connection_string)
+      @logger = logger || ActiveMeasure.logger
+      @tags = filter_tags(tags)
+    end
+
+    # forward all methods to transport
+    METRIC_METHODS = %i(
+    increment
+    decrement
+    count
+    gauge
+    timing
+    time
+    histogram
+    set
+    distribution
+    ).freeze
+
+    def_delegators :@transport, *METRIC_METHODS
+
+
+
+    def parse_connection_string(connection)
+      connection ||= ENV['ActiveMeasure_URL']
+      default_connection = {
+        scheme: 'statsd',
+        host: 'localhost',
+        port: 8125,
+        adapter: 'statsd'
+      }
+
+      return default_connection if connection.nil?
+
+      if connection.is_a?(Hash)
+        connection[:port] ||= default_connection[:port]
+        connection
+      else
+        uri = URI.parse(connection)
+        {
+          scheme: uri.scheme,
+          host: uri.host,
+          port: uri.port || default_connection[:port],
+          adapter: determine_adapter(uri.scheme)
+        }
+      end
+    end
+
+    def filter_tags(tags)
+      (ActiveMeasure.tags || {}).merge(tags || {}).reject { |_, value| value.nil? || value.empty? }
+    end
+
+    private
+
+    def determine_adapter(scheme)
+      case scheme
+      when 'statsd', 'udp', 'http'
+        'statsd'
+      when 'statsdt'
+        'statsd_tagged'
+      when 'unix'
+        'statsd_socket'
+      when 'unixt'
+        'statsd_tagged_socket'
+      else
+        raise "Unknown scheme: #{scheme}"
+      end
+    end
+  end
+end

data/lib/active_measure/configuration.rb

@@ -0,0 +1,32 @@
+require 'singleton'
+
+module ActiveMeasure
+  class Configuration
+    include Singleton
+    attr_reader :logger, :tags
+
+    def initialize
+      @mutex = Mutex.new
+    end
+
+    def logger=(value)
+      @mutex.synchronize { @logger = value }
+    end
+
+    def tags=(value)
+      @mutex.synchronize { @tags = value }
+    end
+  end
+
+  def self.configure
+    yield Configuration.instance
+  end
+
+  def self.logger
+    Configuration.instance.logger
+  end
+
+  def self.tags
+    Configuration.instance.tags
+  end
+end

data/lib/active_measure/logging.rb

@@ -0,0 +1,20 @@
+require 'logger'
+
+module ActiveMeasure
+  module Logging
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def logger
+        @logger ||= Logger.new($stdout)
+      end
+
+      def logger=(new_logger)
+        @logger = new_logger
+      end
+    end
+  end
+end
+

data/lib/active_measure/railtie.rb

@@ -0,0 +1,13 @@
+require 'railtie'
+
+module ActiveMeasure
+  class Railtie < ::Rails::Railtie
+    config.active_measure = ActiveSupport::OrderedOptions.new
+
+    initializer 'active_measure.configur_logger' do |app|
+      ActiveMeasure.configure do |config|
+        config.logger = Rails.logger
+      end
+    end
+  end
+end

data/lib/active_measure/sampler.rb

@@ -0,0 +1,5 @@
+module ActiveMeasure
+  module Sampler
+
+  end
+end

data/lib/active_measure/serializer.rb

@@ -0,0 +1,46 @@
+module ActiveMeasure
+  module Serializer
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Serialize a metric into a string
+      # @param metric [String] The metric to serialize
+      # @example 'company.create'
+      # @param value [Numeric] The value to serialize
+      # @example 1
+      # @param type [String] The type of metric (defaults to 'c')
+      # @example 'ms'
+      # @param tags [Hash] The tags to serialize
+      # @example { company: 'acme', environment: 'production' }
+      # @return [String] Serialized metric string
+      # @example 'company.create;company=acme,environment=production:1|ms'
+      def serialize(metric, value, type: 'c', tags: {})
+        tag_string = tags.map { |key, val| "#{key}=#{val}" }.join(',')
+        "#{metric};#{tag_string}:#{value}|#{type}"
+      end
+
+      # Deserialize a metric from a serialized string
+      # @param serialized_metric [String] The metric string to deserialize
+      # @example 'company.create;company=acme,environment=production:1|ms'
+      # @return [Hash] Deserialized metric as a hash with keys: :metric, :value, :type, and :tags
+      # @example { metric: 'company.create', value: 1.0, type: 'ms', tags: { 'company' => 'acme', 'environment' => 'production' } }
+      def deserialize(serialized_metric)
+        metric, tag_string, value_and_type = serialized_metric.split(';')
+        value, type = value_and_type.split('|')
+
+        tags = {}
+        tag_string.split(',').each do |tag|
+          key, value = tag.split('=')
+          tags[key] = value
+        end
+
+        { metric: metric, value: value.to_f, type: type, tags: tags }
+      rescue => e
+        raise "Failed to deserialize metric: #{e.message}"
+      end
+    end
+  end
+end

data/lib/active_measure/tagging.rb

@@ -0,0 +1,22 @@
+module ActiveMeasure
+  InvalidMetric = Class.new(ArgumentError)
+  module Tagging
+    def self.included(base)
+      base.include InstanceMethods
+    end
+    ## Add tags support to the client, the tags have to be passed in at initialization or at the time of the metric
+    # tags are a hash of key value pairs
+    module InstanceMethods
+      def check_tags(tags)
+        raise InvalidMetric, 'Tags must be a hash' unless tags.is_a?(Hash)
+        ## All keys need to be string and start with a letter, they can contain letters, numbers, underscores.
+        # They cannot contain spaces, dashes, or other special characters.
+        # They cannot be longer than 32 characters
+        # They cannot be empty
+        raise InvalidMetric, 'Tags keys must be basic string' unless tags.keys.all? { |k| k.is_a?(String) && k.match?(/^[a-zA-Z][a-zA-Z0-9_]{0,31}$/) }
+        raise InvalidMetric, 'Tags must be a hash of key value pairs' unless tags.values.all? { |v| v.is_a?(String) }
+      end
+    end
+  end
+end
+

data/lib/active_measure.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'activemeasure'

data/lib/activemeasure.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'active_measure/client'
+require_relative 'active_measure/configuration'
+require_relative 'active_measure/adapters'
+
+module ActiveMeasure
+end
+

data/sig/activecypher.rbs

@@ -0,0 +1,20 @@
+module ActiveMeasure
+  VERSION: String
+
+  class Client
+    type connection_string_type = String | Hash[String, untyped] | nil
+    type tags_type = Hash[String, String]
+
+    DEFAULT_CONNECTION_STRING: String
+
+    attr_reader connection_string: URI::Generic
+    attr_reader logger: Logger
+    attr_reader tags: tags_type
+
+    def initialize: (?connection_string: connection_string_type, ?logger: Logger, ?tags: tags_type) -> void
+
+    def parse_connection_string: (connection_string_type) -> URI::Generic
+
+    def filter_tags: (tags_type?) -> tags_type
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: activemeasure
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Abdelkader Boudih
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-01 00:00:00.000000000 Z
+dependencies: []
+description: ActiveMeasure is vendor agnostic metrics library for Ruby and Rails.
+email:
+- seuros@pre-history.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_measure.rb
+- lib/active_measure/adapters.rb
+- lib/active_measure/adapters/base.rb
+- lib/active_measure/adapters/sink.rb
+- lib/active_measure/adapters/statsd.rb
+- lib/active_measure/adapters/statsd_socket.rb
+- lib/active_measure/adapters/statsd_tagged.rb
+- lib/active_measure/assertions.rb
+- lib/active_measure/buffer.rb
+- lib/active_measure/client.rb
+- lib/active_measure/configuration.rb
+- lib/active_measure/logging.rb
+- lib/active_measure/railtie.rb
+- lib/active_measure/sampler.rb
+- lib/active_measure/serializer.rb
+- lib/active_measure/tagging.rb
+- lib/activemeasure.rb
+- sig/activecypher.rbs
+homepage: https://github.com/seuros/activemetric
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/seuros/activemetric
+  source_code_uri: https://github.com/seuros/activemetric
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: ActiveMeasure is vendor agnostic metrics library for Ruby and Rails.
+test_files: []