cosmos 5.0.3 → 5.0.4

data/lib/cosmos/topics/interface_topic.rb

@@ -34,38 +34,38 @@ module Cosmos
 
     def self.receive_commands(interface, scope:)
       while true
-        Store.read_topics(InterfaceTopic.topics(interface, scope: scope)) do |topic, msg_id, msg_hash, redis|
+        Topic.read_topics(InterfaceTopic.topics(interface, scope: scope)) do |topic, msg_id, msg_hash, redis|
           result = yield topic, msg_hash
           ack_topic = topic.split("__")
           ack_topic[1] = 'ACK' + ack_topic[1]
           ack_topic = ack_topic.join("__")
-          Store.write_topic(ack_topic, { 'result' => result, 'id' => msg_id }, '*', 100)
+          Topic.write_topic(ack_topic, { 'result' => result, 'id' => msg_id }, '*', 100)
         end
       end
     end
 
     def self.write_raw(interface_name, data, scope:)
-      Store.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'raw' => data }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'raw' => data }, '*', 100)
     end
 
     def self.connect_interface(interface_name, scope:)
-      Store.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'connect' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'connect' => 'true' }, '*', 100)
     end
 
     def self.disconnect_interface(interface_name, scope:)
-      Store.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'disconnect' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'disconnect' => 'true' }, '*', 100)
     end
 
     def self.start_raw_logging(interface_name, scope:)
-      Store.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_raw' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_raw' => 'true' }, '*', 100)
     end
 
     def self.stop_raw_logging(interface_name, scope:)
-      Store.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_raw' => 'false' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_raw' => 'false' }, '*', 100)
     end
 
     def self.shutdown(interface, scope:)
-      Store.write_topic("{#{scope}__CMD}INTERFACE__#{interface.name}", { 'shutdown' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface.name}", { 'shutdown' => 'true' }, '*', 100)
       sleep 1 # Give some time for the interface to shutdown
       InterfaceTopic.clear_topics(InterfaceTopic.topics(interface, scope: scope))
     end

data/lib/cosmos/topics/limits_event_topic.rb

@@ -52,13 +52,13 @@ module Cosmos
         raise "Invalid limits event type '#{event[:type]}'"
       end
 
-      Store.write_topic("#{scope}__cosmos_limits_events", event, '*', 1000)
+      Topic.write_topic("#{scope}__cosmos_limits_events", event, '*', 1000)
     end
 
     def self.read(offset = nil, count: 100, scope:)
       topic = "#{scope}__cosmos_limits_events"
       if offset
-        result = Store.xread(topic, offset, count: count)
+        result = Topic.read_topics([topic], [offset], nil, count)
         if result.empty?
           [] # We want to return an empty array rather than an empty hash
         else
@@ -67,7 +67,9 @@ module Cosmos
           result[topic]
         end
       else
-        Store.xrevrange(topic, count: 1)
+        result = Topic.get_newest_message(topic)
+        return [result] if result
+        return []
       end
     end
 

data/lib/cosmos/topics/notifications_topic.rb

@@ -22,7 +22,7 @@ require 'cosmos/topics/topic'
 module Cosmos
   class NotificationsTopic < Topic
     def self.write_notification(notification, scope:)
-      Store.write_topic("#{scope}__cosmos_notifications", notification)
+      Topic.write_topic("#{scope}__cosmos_notifications", notification)
     end
   end
 end

data/lib/cosmos/topics/router_topic.rb

@@ -36,13 +36,13 @@ module Cosmos
 
     def self.receive_telemetry(router, scope:)
       while true
-        Store.read_topics(RouterTopic.topics(router, scope: scope)) do |topic, msg_id, msg_hash, redis|
+        Topic.read_topics(RouterTopic.topics(router, scope: scope)) do |topic, msg_id, msg_hash, redis|
           result = yield topic, msg_hash
           if /CMD}ROUTER/.match?(topic)
             ack_topic = topic.split("__")
             ack_topic[1] = 'ACK' + ack_topic[1]
             ack_topic = ack_topic.join("__")
-            Store.write_topic(ack_topic, { 'result' => result }, msg_id, 100)
+            Topic.write_topic(ack_topic, { 'result' => result }, msg_id, 100)
           end
         end
       end
@@ -51,33 +51,33 @@ module Cosmos
     def self.route_command(packet, target_names, scope:)
       if packet.identified?
         topic = "{#{scope}__CMD}TARGET__#{packet.target_name}"
-        Store.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => packet.packet_name, 'cmd_buffer' => packet.buffer(false) }, '*', 100)
+        Topic.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => packet.packet_name, 'cmd_buffer' => packet.buffer(false) }, '*', 100)
       elsif target_names.length == 1
         topic = "{#{scope}__CMD}TARGET__#{target_names[0]}"
-        Store.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100)
+        Topic.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100)
       else
         raise "No route for command: #{packet.target_name} #{packet.packet_name}"
       end
     end
 
     def self.connect_router(router_name, scope:)
-      Store.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'connect' => true }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'connect' => true }, '*', 100)
     end
 
     def self.disconnect_router(router_name, scope:)
-      Store.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'disconnect' => true }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'disconnect' => true }, '*', 100)
     end
 
     def self.start_raw_logging(router_name, scope:)
-      Store.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_raw' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_raw' => 'true' }, '*', 100)
     end
 
     def self.stop_raw_logging(router_name, scope:)
-      Store.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_raw' => 'false' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_raw' => 'false' }, '*', 100)
     end
 
     def self.shutdown(router, scope:)
-      Store.write_topic("{#{scope}__CMD}ROUTER__#{router.name}", { 'shutdown' => 'true' }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router.name}", { 'shutdown' => 'true' }, '*', 100)
       sleep 1 # Give some time for the interface to shutdown
       RouterTopic.clear_topics(RouterTopic.topics(router, scope: scope))
     end

data/lib/cosmos/topics/telemetry_decom_topic.rb

@@ -43,7 +43,7 @@ module Cosmos
         :received_count => packet.received_count,
         :json_data => JSON.generate(json_hash.as_json),
       }
-      Store.write_topic("#{scope}__DECOM__{#{packet.target_name}}__#{packet.packet_name}", msg_hash, id)
+      Topic.write_topic("#{scope}__DECOM__{#{packet.target_name}}__#{packet.packet_name}", msg_hash, id)
       # Also update the current value table with the latest decommutated data
       CvtModel.set(json_hash, target_name: packet.target_name, packet_name: packet.packet_name, scope: scope)
     end

data/lib/cosmos/topics/telemetry_topic.rb

@@ -30,7 +30,7 @@ module Cosmos
         :received_count => packet.received_count,
         :buffer => packet.buffer(false),
       }
-      Store.write_topic("#{scope}__TELEMETRY__{#{packet.target_name}}__#{packet.packet_name}", msg_hash)
+      Topic.write_topic("#{scope}__TELEMETRY__{#{packet.target_name}}__#{packet.packet_name}", msg_hash)
     end
   end
 end

data/lib/cosmos/topics/timeline_topic.rb

@@ -39,7 +39,7 @@ module Cosmos
     #  }
     # ```
     def self.write_activity(activity, scope:)
-      Store.write_topic("#{scope}#{PRIMARY_KEY}", activity, '*', 1000)
+      Topic.write_topic("#{scope}#{PRIMARY_KEY}", activity, '*', 1000)
     end
   end
 end

data/lib/cosmos/topics/topic.rb

@@ -21,28 +21,33 @@ require 'cosmos/utilities/store'
 
 module Cosmos
   class Topic
-    def self.initialize_streams(topics)
-      Store.initialize_streams(topics)
-    end
-
-    def self.read_topics(topics, offsets = nil, timeout_ms = 1000, &block)
-      Store.read_topics(topics, offsets, timeout_ms, &block)
+    if RUBY_VERSION < "3"
+      # Delegate all unknown class methods to delegate to the EphemeralStore
+      def self.method_missing(message, *args, &block)
+        EphemeralStore.public_send(message, *args, &block)
+      end
+    else
+      # Delegate all unknown class methods to delegate to the EphemeralStore
+      def self.method_missing(message, *args, **kwargs, &block)
+        EphemeralStore.public_send(message, *args, **kwargs, &block)
+      end
     end
 
     def self.clear_topics(topics, maxlen = 0)
-      topics.each do |topic|
-        Store.xtrim(topic, maxlen)
-      end
+      topics.each { |topic| EphemeralStore.xtrim(topic, maxlen) }
     end
 
     def self.topics(scope, key)
-      topics = []
-      loop do
-        token, streams = Store.scan(0, :match => "#{scope}__#{key}__*", :count => 1000)
-        topics.concat(streams)
-        break if token == 0
-      end
-      topics
+      EphemeralStore
+        .scan_each(match: "#{scope}__#{key}__*", type: 'stream', count: 100)
+        .to_a # Change the enumerator into an array
+        .uniq # Scan can return duplicates so ensure unique
+        .sort # Sort not entirely necessary but nice
+    end
+
+    def self.get_cnt(topic)
+      _, packet = EphemeralStore.get_newest_message(topic)
+      packet ? packet["received_count"].to_i : 0
     end
   end
 end

data/lib/cosmos/utilities/logger.rb

@@ -19,7 +19,7 @@
 
 require 'cosmos/core_ext/class'
 require 'cosmos/core_ext/time'
-require 'cosmos/utilities/store'
+require 'cosmos/topics/topic'
 require 'socket'
 require 'logger'
 require 'time'
@@ -174,11 +174,11 @@ module Cosmos
         puts data.to_json if @stdout
         unless @no_store
           if scope
-            Store.write_topic("#{scope}__cosmos_log_messages", data)
+            Topic.write_topic("#{scope}__cosmos_log_messages", data)
           else
             # The base cosmos_log_messages doesn't have an associated logger
             # so it must be limited to prevent unbounded stream growth
-            Store.write_topic("cosmos_log_messages", data, '*', 1000)
+            Topic.write_topic("cosmos_log_messages", data, '*', 1000)
           end
         end
       end

data/lib/cosmos/utilities/metric.rb

@@ -18,6 +18,7 @@
 # copyright holder
 
 require 'cosmos/models/metric_model'
+require 'thread'
 
 module Cosmos
   class Metric
@@ -48,6 +49,7 @@ module Cosmos
       @scope = scope
       @microservice = microservice
       @size = 5000
+      @mutex = Mutex.new
     end
 
     def add_sample(name:, value:, labels:)
@@ -69,15 +71,17 @@ module Cosmos
       # the value is added to @items and the count of the value is increased
       # if the count of the values exceed the size of the array it sets the
       # count back to zero and the array will over write older data.
-      key = "#{name}|" + labels.map { |k, v| "#{k}=#{v}" }.join(',')
-      if not @items.has_key?(key)
-        Logger.debug("new data for #{@scope}, #{key}")
-        @items[key] = { 'values' => Array.new(@size), 'count' => 0 }
+      @mutex.synchronize do
+        key = "#{name}|" + labels.map { |k, v| "#{k}=#{v}" }.join(',')
+        if not @items.has_key?(key)
+          Logger.debug("new data for #{@scope}, #{key}")
+          @items[key] = { 'values' => Array.new(@size), 'count' => 0 }
+        end
+        count = @items[key]['count']
+        # Logger.info("adding data for #{@scope}, #{count} #{key}, #{value}")
+        @items[key]['values'][count] = value
+        @items[key]['count'] = count + 1 >= @size ? 0 : count + 1
       end
-      count = @items[key]['count']
-      # Logger.info("adding data for #{@scope}, #{count} #{key}, #{value}")
-      @items[key]['values'][count] = value
-      @items[key]['count'] = count + 1 >= @size ? 0 : count + 1
     end
 
     def percentile(sorted_values, percentile)
@@ -106,24 +110,26 @@ module Cosmos
       # array. to store the array as the value with the metric name again joined
       # with the @microservice and @scope.
       Logger.debug("#{@microservice} #{@scope} sending metrics to redis, #{@items.length}") if @items.length > 0
-      @items.each do |key, values|
-        label_list = []
-        name, labels = key.split('|')
-        metric_labels = labels.nil? ? {} : labels.split(',').map { |x| x.split('=') }.map { |k, v| { k => v } }.reduce({}, :merge)
-        sorted_values = values['values'].compact.sort
-        for percentile_value in [10, 50, 90, 95, 99]
-          percentile_result = percentile(sorted_values, percentile_value)
-          labels = metric_labels.clone.merge({ 'scope' => @scope, 'microservice' => @microservice })
-          labels['percentile'] = percentile_value
-          labels['metric__value'] = percentile_result
-          label_list.append(labels)
-        end
-        begin
-          Logger.debug("sending metrics summary to redis key: #{@microservice}")
-          metric = MetricModel.new(name: @microservice, scope: @scope, metric_name: name, label_list: label_list)
-          metric.create(force: true)
-        rescue RuntimeError
-          Logger.error("failed attempt to update metric, #{key}, #{name} #{@scope}")
+      @mutex.synchronize do
+        @items.each do |key, values|
+          label_list = []
+          name, labels = key.split('|')
+          metric_labels = labels.nil? ? {} : labels.split(',').map { |x| x.split('=') }.map { |k, v| { k => v } }.reduce({}, :merge)
+          sorted_values = values['values'].compact.sort
+          for percentile_value in [10, 50, 90, 95, 99]
+            percentile_result = percentile(sorted_values, percentile_value)
+            labels = metric_labels.clone.merge({ 'scope' => @scope, 'microservice' => @microservice })
+            labels['percentile'] = percentile_value
+            labels['metric__value'] = percentile_result
+            label_list.append(labels)
+          end
+          begin
+            Logger.debug("sending metrics summary to redis key: #{@microservice}")
+            metric = MetricModel.new(name: @microservice, scope: @scope, metric_name: name, label_list: label_list)
+            metric.create(force: true)
+          rescue RuntimeError
+            Logger.error("failed attempt to update metric, #{key}, #{name} #{@scope}")
+          end
         end
       end
     end

data/lib/cosmos/utilities/s3.rb

@@ -45,7 +45,7 @@ module Cosmos
           delimiter: '/',
           continuation_token: token
         })
-        
+
         resp.common_prefixes.each do |item|
           folder_list << item.prefix
         end

data/lib/cosmos/utilities/s3_file_cache.rb

@@ -18,6 +18,7 @@
 # copyright holder
 
 require 'fileutils'
+require 'tmpdir'
 require 'cosmos'
 require 'cosmos/utilities/s3'
 
@@ -48,7 +49,7 @@ class S3File
 
   def retrieve
     local_path = "#{S3FileCache.instance.cache_dir}/#{File.basename(@s3_path)}"
-    Cosmos::Logger.info "Retrieving #{@s3_path} from logs bucket"
+    Cosmos::Logger.debug "Retrieving #{@s3_path} from logs bucket"
     @rubys3_client.get_object(bucket: "logs", key: @s3_path, response_target: local_path)
     if File.exist?(local_path)
       @size = File.size(local_path)
@@ -57,6 +58,7 @@ class S3File
   rescue => err
     @error = err
     Cosmos::Logger.error "Failed to retrieve #{@s3_path}\n#{err.formatted}"
+    raise err
   end
 
   def reserve
@@ -165,11 +167,11 @@ class S3FileCache
     end
 
     # Create local file cache location
-    @cache_dir = File.join(Dir.tmpdir, 'cosmos', 'file_cache', name)
+    @cache_dir = Dir.mktmpdir
     FileUtils.mkdir_p(@cache_dir)
-
-    # Clear out local file cache
-    FileUtils.rm_f Dir.glob("#{@cache_dir}/*")
+    at_exit do
+      FileUtils.remove_dir(@cache_dir, true)
+    end
 
     @cached_files = S3FileCollection.new
 
@@ -178,7 +180,11 @@ class S3FileCache
         file = @cached_files.get_next_to_retrieve
         # Cosmos::Logger.debug "Next file: #{file}"
         if file and (file.size + @cached_files.current_disk_usage()) <= @max_disk_usage
-          file.retrieve
+          begin
+            file.retrieve
+          rescue
+            # Will be automatically retried
+          end
         else
           sleep(1)
         end

data/lib/cosmos/utilities/store.rb

@@ -19,4 +19,5 @@
 
 module Cosmos
   autoload(:Store, "cosmos/utilities/store_autoload.rb")
+  autoload(:EphemeralStore, "cosmos/utilities/store_autoload.rb")
 end

data/lib/cosmos/utilities/store_autoload.rb

@@ -31,7 +31,7 @@ end
 module Cosmos
   class Store
     # Variable that holds the singleton instance
-    @@instance = nil
+    @instance = nil
 
     # Mutex used to ensure that only one instance is created
     @@instance_mutex = Mutex.new
@@ -42,11 +42,11 @@ module Cosmos
     # Get the singleton instance
     def self.instance(pool_size = 100)
       # Logger.level = Logger::DEBUG
-      return @@instance if @@instance
+      return @instance if @instance
 
       @@instance_mutex.synchronize do
-        @@instance ||= self.new(pool_size)
-        return @@instance
+        @instance ||= self.new(pool_size)
+        return @instance
       end
     end
 
@@ -87,44 +87,10 @@ module Cosmos
       end
     end
 
-    def get_cmd_item(target_name, packet_name, param_name, type: :WITH_UNITS, scope: $cosmos_scope)
-      msg_id, msg_hash = read_topic_last("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}")
-      if msg_id
-        # TODO: We now have these reserved items directly on command packets
-        # Do we still calculate from msg_hash['time'] or use the times directly?
-        #
-        # if param_name == 'RECEIVED_TIMESECONDS' || param_name == 'PACKET_TIMESECONDS'
-        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).to_f
-        # elsif param_name == 'RECEIVED_TIMEFORMATTED' || param_name == 'PACKET_TIMEFORMATTED'
-        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).formatted
-        if param_name == 'RECEIVED_COUNT'
-          msg_hash['received_count'].to_i
-        else
-          json = msg_hash['json_data']
-          hash = JSON.parse(json)
-          # Start from the most complex down to the basic raw value
-          value = hash["#{param_name}__U"]
-          return value if value && type == :WITH_UNITS
-
-          value = hash["#{param_name}__F"]
-          return value if value && (type == :WITH_UNITS || type == :FORMATTED)
-
-          value = hash["#{param_name}__C"]
-          return value if value && (type == :WITH_UNITS || type == :FORMATTED || type == :CONVERTED)
-
-          return hash[param_name]
-        end
-      end
-    end
-
     ###########################################################################
     # Stream APIs
     ###########################################################################
 
-    def self.initialize_streams(topics)
-      self.instance.initialize_streams(topics)
-    end
-
     def initialize_streams(topics)
       @redis_pool.with do |redis|
         topics.each do |topic|
@@ -134,48 +100,18 @@ module Cosmos
       end
     end
 
-    def self.get_oldest_message(topic)
-      self.instance.get_oldest_message(topic)
-    end
-
     def get_oldest_message(topic)
       @redis_pool.with do |redis|
         result = redis.xrange(topic, count: 1)
-        return result[0]
-      end
-    end
-
-    def self.get_newest_message(topic)
-      self.instance.get_newest_message(topic)
-    end
-
-    def get_newest_message(topic)
-      @redis_pool.with do |redis|
-        result = redis.xrevrange(topic, count: 1)
-        return result[0]
-      end
-    end
-
-    def self.get_last_offset(topic)
-      self.instance.get_last_offset(topic)
-    end
-
-    def get_last_offset(topic)
-      @redis_pool.with do |redis|
-        result = redis.xrevrange(topic, count: 1)
-        if result and result[0] and result[0][0]
-          result[0][0]
+        if result and result.length > 0
+          return result[0]
         else
-          "0-0"
+          return nil
         end
       end
     end
 
-    def self.read_topic_last(topic)
-      self.instance.read_topic_last(topic)
-    end
-
-    def read_topic_last(topic)
+    def get_newest_message(topic)
       @redis_pool.with do |redis|
         # Default in xrevrange is range end '+', start '-' which means get all
         # elements from higher ID to lower ID and since we're limiting to 1
@@ -189,18 +125,15 @@ module Cosmos
       end
     end
 
-    # TODO: Currently unused
-    # def decrement_id(id)
-    #   time, sequence = id.split('-')
-    #   if sequence == '0'
-    #     "#{time.to_i - 1}-18446744073709551615"
-    #   else
-    #     "#{time}-#{sequence.to_i - 1}"
-    #   end
-    # end
-
-    def self.update_topic_offsets(topics)
-      self.instance.update_topic_offsets(topics)
+    def get_last_offset(topic)
+      @redis_pool.with do |redis|
+        result = redis.xrevrange(topic, count: 1)
+        if result and result[0] and result[0][0]
+          result[0][0]
+        else
+          "0-0"
+        end
+      end
     end
 
     def update_topic_offsets(topics)
@@ -221,15 +154,12 @@ module Cosmos
       return offsets
     end
 
-    def self.read_topics(topics, offsets = nil, timeout_ms = 1000, &block)
-      self.instance.read_topics(topics, offsets, timeout_ms, &block)
-    end
     unless $enterprise_cosmos
-      def read_topics(topics, offsets = nil, timeout_ms = 1000)
+      def read_topics(topics, offsets = nil, timeout_ms = 1000, count = nil)
         # Logger.debug "read_topics: #{topics}, #{offsets} pool:#{@redis_pool}"
         @redis_pool.with do |redis|
           offsets = update_topic_offsets(topics) unless offsets
-          result = redis.xread(topics, offsets, block: timeout_ms)
+          result = redis.xread(topics, offsets, block: timeout_ms, count: count)
           if result and result.length > 0
             result.each do |topic, messages|
               messages.each do |msg_id, msg_hash|
@@ -244,26 +174,6 @@ module Cosmos
       end
     end
 
-    # Add new entry to the redis stream.
-    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xadd
-    #
-    # @example Without options
-    #   COSMOS::Store().write_topic('MANGO__TOPIC', {'message' => 'something'})
-    # @example With options
-    #   COSMOS::Store().write_topic('MANGO__TOPIC', {'message' => 'something'}, id: '0-0', maxlen: 1000, approximate: false)
-    #
-    # @param topic [String] the stream / topic
-    # @param msg_hash [Hash]   one or multiple field-value pairs
-    #
-    # @option opts [String]  :id          the entry id, default value is `*`, it means auto generation
-    # @option opts [Integer] :maxlen      max length of entries
-    # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen or not
-    #
-    # @return [String] the entry id
-    def self.write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = true)
-      self.instance.write_topic(topic, msg_hash, id, maxlen, approximate)
-    end
-
     # Add new entry to the redis stream.
     # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xadd
     #
@@ -289,23 +199,6 @@ module Cosmos
       end
     end
 
-    # Trims older entries of the redis stream if needed.
-    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xtrim
-    #
-    # @example Without options
-    #   COSMOS::Store.trim_topic('MANGO__TOPIC', 1000)
-    # @example With options
-    #   COSMOS::Store.trim_topic('MANGO__TOPIC', 1000, approximate: true, limit: 0)
-    #
-    # @param topic  [String]  the stream key
-    # @param minid  [Integer] max length of entries to trim
-    # @param limit  [Boolean] whether to add `~` modifier of maxlen or not
-    #
-    # @return [Integer] the number of entries actually deleted
-    def self.trim_topic(topic, minid, approximate = true, limit: 0)
-      self.instance.trim_topic(topic, minid, approximate, limit: limit)
-    end
-
     # Trims older entries of the redis stream if needed.
     # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xtrim
     #
@@ -325,6 +218,14 @@ module Cosmos
       end
     end
   end
+
+  class EphemeralStore < Store
+    def initialize(pool_size = 10)
+      super(pool_size)
+      @redis_url = "redis://#{ENV['COSMOS_REDIS_EPHEMERAL_HOSTNAME']}:#{ENV['COSMOS_REDIS_EPHEMERAL_PORT']}"
+      @redis_pool = ConnectionPool.new(size: pool_size) { build_redis() }
+    end
+  end
 end
 
 class Redis

data/lib/cosmos/version.rb

@@ -1,14 +1,14 @@
 # encoding: ascii-8bit
 
-COSMOS_VERSION = '5.0.3'
+COSMOS_VERSION = '5.0.4'
 module Cosmos
   module Version
     MAJOR = '5'
     MINOR = '0'
-    PATCH = '3'
+    PATCH = '4'
     OTHER = ''
-    BUILD = '715c106240ff43bb59be2d17d1f5aed50595fbc9'
+    BUILD = '84d6dcebd4bc21e5559963be4e5fde2ddb7e9822'
   end
-  VERSION = '5.0.3'
-  GEM_VERSION = '5.0.3'
+  VERSION = '5.0.4'
+  GEM_VERSION = '5.0.4'
 end