statisfy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5bf901bb209f43e88099e395db0b4651e1c9b49aa119fdcbe0d941b8434e058a
+  data.tar.gz: 5330f8c09b29c28c16117c9ef633cd94cd9af12df70f299a4ef71bb730cde91c
+SHA512:
+  metadata.gz: 4d2ad92ebf235e4114f424e770487d29d78940cba1d6b590840bb15610446125d7713623e692f9817d3b4cc5a34eafb2cbe3930509e1b20d07bdcd7a06dbf701
+  data.tar.gz: 3e4e9141247f501ca1c7a7aeb0fff50a63c27020e5035b4a3c21d5e0ebcd482ab6ce4146c1d1c7834144e630ec39b574973ec1721b3d96e541d468d8c6df6ea7

data/lib/statisfy/aggregate.rb

@@ -0,0 +1,35 @@
+require_relative "counter"
+
+module Statisfy
+  module Aggregate
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.class_eval do
+        include Counter
+      end
+    end
+
+    module ClassMethods
+      #
+      # Simply a shortcut for declaring an aggregation type counter
+      #
+      def aggregate(args = {})
+        raise ArgumentError, "You must provide the value to aggregate" if args[:value].blank?
+
+        count(args.merge(type: :aggregate))
+      end
+
+      #
+      # Average type counters ret
+      #
+      # @param scope: the scope of the counter (an Organisation or a Department)
+      # @param month: the month for which you want the value of the counter (optional)
+      #
+      def value(scope: nil, month: nil)
+        p "HEIN???"
+        month = month&.strftime("%Y-%m") if month.present?
+        average(scope:, month:)
+      end
+    end
+  end
+end

data/lib/statisfy/configuration.rb

@@ -0,0 +1,15 @@
+module Statisfy
+  class Configuration
+    attr_accessor(
+      :default_scopes,
+      :redis_client,
+      :append_to_counters,
+      :default_async_method,
+      :counters_path
+    )
+
+    def initialize
+      @default_async_method = :perform_async
+    end
+  end
+end

data/lib/statisfy/counter.rb

@@ -0,0 +1,215 @@
+require_relative "subscriber"
+require_relative "monthly"
+
+module Statisfy
+  module Counter
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.class_eval do
+        include Subscriber, Monthly
+        attr_accessor :params, :subject
+      end
+    end
+
+    module ClassMethods
+      #
+      # This is a DSL method that helps you define a counter
+      # It will create a method that will be called when the event is triggered
+      # It will also create a method that will be called when you want to get the value of the counter
+      #
+      # @param every: the event(s) that will trigger the counter
+      # @param type: by default it increments, but you can also use :average
+      # @param if: a block that returns a condition that must be met for the counter to be incremented (optional)
+      # @param if_async: same as if option but runs async to avoid slowing down inserts and updates (optional)
+      # @param uniq_by: a block to get the identifier of the element to be counted (optional)
+      # @param scopes: a block to get the list of scopes for which the counter must be incremented (optional)
+      #
+      def count(args = {})
+        raise ArgumentError, "You must provide at least one event" if args[:every].blank?
+
+        catch_events(*args[:every], if: args[:if] || -> { true })
+        apply_default_counter_options(args)
+        const_set(:COUNTER_TYPE, args[:type] || :increment)
+        class_eval(&Statisfy.configuration.append_to_counters) if Statisfy.configuration.append_to_counters.present?
+      end
+
+      #
+      # This method serves as a syntactic sugar
+      # The below methods could be written directly in the class definition
+      # but the `count` DSL defines them automatically based on the options provided
+      #
+      def apply_default_counter_options(args)
+        define_method(:identifier, args[:uniq_by] || -> { params["id"] })
+        define_method(:scopes, args[:scopes] || Statisfy.configuration.default_scopes || -> { [] })
+        define_method(:if_async, args[:if_async] || -> { true })
+        define_method(:decrement?, args[:decrement_if] || -> { false })
+        define_method(:value, args[:value] || -> {})
+        define_method(:should_run?, args[:if] || -> { true })
+      end
+
+      #
+      # This is the method that is called when you want to get the value of a counter.
+      #
+      # By default it returns the number of elements in the set.
+      # You can override it if the counter requires more complex logic
+      # see RateOfAutonomousUsers for example
+      #
+      # @param scope: the scope of the counter (an Organisation or a Department)
+      # @param month: the month for which you want the value of the counter (optional)
+      #
+      def value(scope: nil, month: nil)
+        month = month&.strftime("%Y-%m") if month.present?
+        if const_get(:COUNTER_TYPE) == :aggregate
+          average(scope:, month:)
+        else
+          size(scope:, month:)
+        end
+      end
+
+      def size(scope: nil, month: nil)
+        redis_client.scard(key_for(scope:, month:))
+      end
+
+      #
+      # Returns the list of elements in the set (in case you use .append and not .increment)
+      #
+      def elements_in(scope: nil, month: nil)
+        redis_client.lrange(key_for(scope:, month:), 0, -1)
+      end
+
+      def sum(scope: nil, month: nil)
+        stored_values = elements_in(scope:, month:)
+        return 0 if stored_values.empty?
+
+        stored_values.map(&:to_i).reduce(:+)
+      end
+
+      #
+      # Returns the average of the elements in the set
+      # Example:
+      # append(value: 1)
+      # append(value: 2)
+      # average
+      # => 1.5
+      #
+      def average(scope: nil, month: nil)
+        stored_values = elements_in(scope:, month:)
+        return 0 if stored_values.empty?
+
+        stored_values.map(&:to_i).reduce(:+) / stored_values.length.to_f
+      end
+
+      #
+      # This is the name of the Redis key that will be used to store the counter
+      #
+      def key_for(scope:, month: nil)
+        {
+          counter: name.demodulize.underscore,
+          month:,
+          scope_type: scope&.class&.name,
+          scope_id: scope&.id
+        }.to_json
+      end
+
+      def redis_client
+        Statisfy.configuration.redis_client
+      end
+
+      #
+      # This allows to run a counter increment manually
+      # It is useful when you want to backfill counters
+      #
+      def initialize_with(resource, options = {})
+        counter = new
+        counter.params = resource
+
+        return unless options[:skip_validation] || counter.should_run?
+
+        counter.perform(resource)
+      end
+
+      #
+      # Returns the list of all the keys of this counter for a given scope (optional)
+      # and a given month (optional)
+      #
+      def all_keys(scope: nil, month: nil)
+        redis_client.keys("*\"counter\":\"#{name.demodulize.underscore}\"*").filter do |json|
+          key = JSON.parse(json)
+
+          scope_matches = scope.nil? || (key["scope_type"] == scope.class.name && key["scope_id"] == scope.id)
+          month_matches = month.nil? || key["month"] == month
+
+          scope_matches && month_matches
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      #
+      # This allows to reset all the counters for a given scope (optional)
+      # and a given month (optional)
+      #
+      def reset(scope: nil, month: nil)
+        all_keys(scope:, month:).each do |key|
+          redis_client.del(key)
+        end
+
+        true
+      end
+    end
+
+    protected
+
+    def scopes_with_global
+      scopes.flatten.compact << nil
+    end
+
+    def month_to_set
+      params["created_at"].to_date.strftime("%Y-%m")
+    end
+
+    def process_event
+      return unless if_async
+
+      if value.present?
+        append(value:)
+      else
+        decrement? ? decrement : increment
+      end
+    end
+
+    #
+    # This allows to iterate over all the counters that need to be updated
+    # (in general the Department(s) and Organisation(s) for both the current month and the global counter)
+    #
+    def all_counters
+      [month_to_set, nil].each do |month|
+        scopes_with_global.each do |scope|
+          yield self.class.key_for(scope:, month:), identifier
+        end
+      end
+    end
+
+    def increment
+      all_counters do |key, id|
+        self.class.redis_client.sadd?(key, id)
+      end
+    end
+
+    def decrement
+      all_counters do |key, id|
+        self.class.redis_client.srem?(key, id)
+      end
+    end
+
+    #
+    # To be used to store a list of values instead of a basic counter
+    #
+    def append(value:)
+      all_counters do |key|
+        self.class.redis_client.rpush(key, value)
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/ModuleLength

data/lib/statisfy/monthly.rb

@@ -0,0 +1,41 @@
+module Statisfy
+  module Monthly
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      #
+      # Returns a hash of values grouped by month:
+      # {
+      #   "01/2024" => 33.3,
+      #   "02/2024" => 36.6,
+      #   "03/2024" => 38.2,
+      # }
+      #
+      # @param scope: the scope of the counter (an Organisation or a Department)
+      # @param start_at: the date from which you want to start counting (optional)
+      # @param stop_at: the date at which you want to stop counting (optional)
+      #
+      def values_grouped_by_month(scope: nil, start_at: nil, stop_at: nil)
+        n_months = 24
+
+        if start_at.present? || scope&.created_at.present?
+          start_at ||= scope.created_at
+          n_months = (Time.zone.today.year + Time.zone.today.month) - (start_at.year + start_at.month)
+        end
+
+        relevant_months = (0..n_months).map do |i|
+          (n_months - i).months.ago.beginning_of_month
+        end
+
+        relevant_months
+          .filter { |month| stop_at.blank? || month < stop_at }
+          .to_h do |month|
+          [month.strftime("%m/%Y"), value(scope:, month:).round(2)]
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/statisfy/subscriber.rb

@@ -0,0 +1,74 @@
+module Statisfy
+  module Subscriber
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def catch_events(*event_names, **options)
+        define_method(:should_run?, &options[:if] || -> { true })
+        [*event_names].flatten.map do |event_name|
+          model_and_event_from_event_name(event_name).tap do |model, event|
+            append_callback_to_model(model, event)
+            define_subject_method(model)
+          end
+        end
+      end
+
+      def append_callback_to_model(model, event)
+        listener = self
+        model.class_eval do
+          after_commit on: event do
+            counter = listener.new
+            counter.subject = self
+
+            next unless counter.should_run?
+
+            if listener.respond_to?(Statisfy.configuration.default_async_method)
+              listener.send(Statisfy.configuration.default_async_method, attributes)
+            else
+              counter.perform(attributes)
+            end
+          end
+        end
+      end
+
+      def model_and_event_from_event_name(event_name)
+        model_with_event = event_name.to_s.split("_")
+        event = {
+          "created": :create,
+          "updated": :update,
+          "destroyed": :destroy
+        }[model_with_event.pop.to_sym]
+
+        model_name = model_with_event.join("_").camelize
+
+        [Object.const_get(model_name), event]
+      rescue NameError
+        raise Statisfy::Error, "The model #{model_name} does not exist"
+      end
+
+      def define_subject_method(model)
+        instance_name = model.name.underscore
+        return if method_defined?(instance_name)
+
+        define_method(instance_name) do
+          model = instance_name.camelize.constantize
+          @subject ||= model.find_by(id: params["id"])
+        end
+        alias_method :subject, instance_name
+      end
+    end
+
+    #
+    # This is the method that will be called when an event is triggered
+    # It will be executed in the background by Sidekiq
+    #
+    # @resource_or_hash [Hash] The attributes of the model that triggered the event + the previous_changes
+    #
+    def perform(resource_or_hash)
+      @params = resource_or_hash
+      process_event
+    end
+  end
+end

data/lib/statisfy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "statisfy/configuration"
+require_relative "statisfy/counter"
+require_relative "statisfy/aggregate"
+require_relative "statisfy/monthly"
+
+module Statisfy
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: statisfy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michaël Villeneuve
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.4.3
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.4.3
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.8.1
+- !ruby/object:Gem::Dependency
+  name: redis-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.49.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.49.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.9
+description: A performant and flexible counter solution that allows to make statistics
+  on your models
+email: contact@michaelvilleneuve.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/statisfy.rb
+- lib/statisfy/aggregate.rb
+- lib/statisfy/configuration.rb
+- lib/statisfy/counter.rb
+- lib/statisfy/monthly.rb
+- lib/statisfy/subscriber.rb
+homepage: https://github.com/Michaelvilleneuve/statisfy
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A performant and flexible counter solution
+test_files: []