event_meter 0.1.0

data/lib/event_meter/stores/redis_lock.rb

@@ -0,0 +1,77 @@
+require "securerandom"
+
+require_relative "lock_refresher"
+
+module EventMeter
+  module Stores
+    module RedisLock
+      LOCK_REFRESH_RATIO = 2.0
+
+      private
+
+      def with_redis_lock(key, ttl:)
+        ttl = redis_lock_ttl(ttl)
+        token = SecureRandom.hex(16)
+        acquired = lock_redis.set(key, token, nx: true, ex: ttl)
+        return false unless acquired
+
+        refresher = start_redis_lock_refresher(key, token, ttl)
+        yield
+        true
+      ensure
+        stop_redis_lock_refresher(refresher)
+        release_redis_lock(key, token) if acquired
+      end
+
+      def release_redis_lock(key, token)
+        lock_redis.eval(<<~LUA, keys: [key], argv: [token])
+          if redis.call("get", KEYS[1]) == ARGV[1] then
+            return redis.call("del", KEYS[1])
+          end
+
+          return 0
+        LUA
+      end
+
+      def refresh_redis_lock(key, token, ttl)
+        result = lock_redis.eval(<<~LUA, keys: [key], argv: [token, ttl])
+          if redis.call("get", KEYS[1]) == ARGV[1] then
+            return redis.call("expire", KEYS[1], ARGV[2])
+          end
+
+          return 0
+        LUA
+
+        result == true || result.to_s == "1"
+      end
+
+      def start_redis_lock_refresher(key, token, ttl)
+        LockRefresher.new(
+          interval: ttl.to_f / LOCK_REFRESH_RATIO,
+          refresh: -> { refresh_redis_lock(key, token, ttl) },
+          failure_message: "redis lock refresh failed",
+          thread_name: "event_meter redis lock refresher"
+        ).start
+      end
+
+      def stop_redis_lock_refresher(refresher)
+        return unless refresher
+
+        refresher.stop
+      end
+
+      def redis_lock_ttl(ttl)
+        ttl = Integer(ttl)
+        return ttl if ttl.positive?
+
+        raise ArgumentError, "lock ttl must be positive"
+      rescue ArgumentError, TypeError, RangeError
+        raise ArgumentError, "lock ttl must be positive"
+      end
+
+      def lock_redis
+        redis
+      end
+    end
+  end
+end

data/lib/event_meter/stores/rollup/active_record_postgres.rb

@@ -0,0 +1,135 @@
+require_relative "postgres"
+
+module EventMeter
+  module Stores
+    module Rollup
+      class ActiveRecordPostgres < Postgres
+        class Connection
+          TRANSACTION_COMMANDS = {
+            "BEGIN" => :begin,
+            "COMMIT" => :finish,
+            "ROLLBACK" => :finish
+          }.freeze
+
+          attr_reader :connection_class
+
+          def initialize(connection_class)
+            @connection_class = connection_class
+            @transaction_connection = nil
+          end
+
+          def exec(sql)
+            with_connection_for(sql) { |connection| connection.exec(sql) }
+          end
+
+          def exec_params(sql, params)
+            with_connection_for(sql) { |connection| connection.exec_params(sql, params) }
+          end
+
+          private
+
+          def with_connection_for(sql)
+            command = transaction_command(sql)
+
+            return begin_transaction { |connection| yield connection } if command == :begin
+            return finish_transaction { |connection| yield connection } if command == :finish
+            return yield active_raw_connection if transaction_open?
+
+            connection_pool.with_connection do |connection|
+              yield connection.raw_connection
+            end
+          end
+
+          def begin_transaction
+            raise ConfigurationError, "event_meter postgres transaction is already open" if transaction_open?
+
+            @transaction_connection = connection_pool.checkout
+            yield active_raw_connection
+          rescue StandardError
+            checkin_transaction_connection
+            raise
+          end
+
+          def finish_transaction
+            return with_connection_for_non_transaction { |connection| yield connection } unless transaction_open?
+
+            yield active_raw_connection
+          ensure
+            checkin_transaction_connection
+          end
+
+          def with_connection_for_non_transaction
+            connection_pool.with_connection do |connection|
+              yield connection.raw_connection
+            end
+          end
+
+          def transaction_command(sql)
+            TRANSACTION_COMMANDS[sql.to_s.strip.upcase]
+          end
+
+          def transaction_open?
+            !@transaction_connection.nil?
+          end
+
+          def active_raw_connection
+            @transaction_connection.raw_connection
+          end
+
+          def checkin_transaction_connection
+            connection = @transaction_connection
+            @transaction_connection = nil
+            connection_pool.checkin(connection) if connection
+          end
+
+          def connection_pool
+            connection_class.connection_pool
+          end
+        end
+
+        attr_reader :connection_class
+
+        def self.install!(connection_class: default_connection_class, table_prefix: "event_meter")
+          connection_class.connection_pool.with_connection do |connection|
+            Postgres.install!(
+              connection: connection.raw_connection,
+              table_prefix: table_prefix
+            )
+          end
+        end
+
+        def self.default_connection_class
+          return ::ActiveRecord::Base if defined?(::ActiveRecord::Base)
+
+          raise ConfigurationError, "ActiveRecord is required for active_record_postgres rollup storage"
+        end
+
+        def initialize(connection_class: self.class.default_connection_class, lock_connection: nil, **options)
+          @connection_class = connection_class
+          super(
+            connection: Connection.new(connection_class),
+            lock_connection: lock_connection || Connection.new(connection_class),
+            **options
+          )
+        end
+
+        def for_report(name:, version:)
+          name = name.to_s
+          version = version.to_i
+
+          self.class.new(
+            connection_class: connection_class,
+            connection_lock: connection_lock,
+            lock_connection: lock_connection,
+            lock_connection_lock: lock_connection_lock,
+            namespace: namespace,
+            table_prefix: table_prefix,
+            report_name: name,
+            version: version,
+            lock_scope: "#{Keys.event_name(name)}:#{Keys.version_key(version)}"
+          )
+        end
+      end
+    end
+  end
+end