cosmos 5.0.2.pre.beta2 → 5.0.4

data/lib/cosmos/api/settings_api.rb

@@ -19,8 +19,6 @@
 
 module Cosmos
   module Api
-    SETTINGS_KEY = "cosmos__settings"
-
     WHITELIST ||= []
     WHITELIST.concat([
                        'list_settings',
@@ -31,28 +29,42 @@ module Cosmos
                      ])
 
     def list_settings(scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hkeys(SETTINGS_KEY)
+      authorize(permission: 'system', scope: scope, token: token)
+      SettingsModel.names(scope: scope)
     end
 
     def get_all_settings(scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hgetall(SETTINGS_KEY)
+      authorize(permission: 'system', scope: scope, token: token)
+      SettingsModel.all(scope: scope)
     end
 
     def get_setting(name, scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hget(SETTINGS_KEY, name)
+      authorize(permission: 'system', scope: scope, token: token)
+      setting = SettingsModel.get(name: name, scope: scope)
+      if setting
+        return setting["data"]
+      else
+        return nil
+      end
     end
 
     def get_settings(*args, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system', scope: scope, token: token)
       ret = []
       args.each do |name|
-        ret << Store.instance.hget(SETTINGS_KEY, name)
+        setting = SettingsModel.get(name: name, scope: scope)
+        if setting
+          ret << setting["data"]
+        else
+          ret << nil
+        end
       end
       return ret
     end
 
     def save_setting(name, data, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'admin', scope: scope, token: token)
-      Store.instance.hset(SETTINGS_KEY, name, data)
+      SettingsModel.set({ name: name,  data: data }, scope: scope)
     end
   end
 end

data/lib/cosmos/api/target_api.rb

@@ -56,12 +56,12 @@ module Cosmos
         cmd_cnt = 0
         packets = TargetModel.packets(target_name, type: :CMD, scope: scope)
         packets.each do |packet|
-          cmd_cnt += _get_cnt("#{scope}__COMMAND__{#{target_name}}__#{packet['packet_name']}")
+          cmd_cnt += Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{packet['packet_name']}")
         end
         tlm_cnt = 0
         packets = TargetModel.packets(target_name, type: :TLM, scope: scope)
         packets.each do |packet|
-          tlm_cnt += _get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}")
+          tlm_cnt += Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}")
         end
         interface_name = ''
         InterfaceModel.all(scope: scope).each do |name, interface|

data/lib/cosmos/api/tlm_api.rb

@@ -19,6 +19,8 @@
 
 require 'cosmos/models/target_model'
 require 'cosmos/models/cvt_model'
+require 'cosmos/packets/packet'
+require 'cosmos/topics/telemetry_topic'
 require 'cosmos/utilities/s3'
 
 module Cosmos
@@ -38,10 +40,11 @@ module Cosmos
                        'get_tlm_packet',
                        'get_tlm_values',
                        'get_all_telemetry',
+                       'get_all_telemetry_list',
                        'get_telemetry',
                        'get_item',
                        'subscribe_packets',
-                       'get_packet',
+                       'get_packets',
                        'get_all_tlm_info',
                        'get_tlm_cnt',
                        'get_packet_derived_items',
@@ -125,19 +128,18 @@ module Cosmos
         # Check that the packet exists ... exceptions are raised if not
         TargetModel.packet(target_name, packet_name, scope: scope)
       end
-      inject = {}
-      inject['inject_tlm'] = true
-      inject['log'] = log
-      inject['target_name'] = target_name
-      inject['packet_name'] = packet_name
-      inject['item_hash'] = JSON.generate(item_hash) if item_hash
-      inject['type'] = type
-
-      InterfaceModel.all(scope: scope).each do |name, interface|
-        if interface['target_names'].include? target_name
-          Store.write_topic("{#{scope}__CMD}INTERFACE__#{interface['name']}", inject, '*', 100)
+
+      packet_hash = get_telemetry(target_name, packet_name, scope: scope, token: token)
+      packet = Packet.from_json(packet_hash)
+      if item_hash
+        item_hash.each do |name, value|
+          packet.write(name.to_s, value, type)
         end
       end
+      packet.received_time = Time.now.sys
+      # TODO: New packet so received_count is not correct
+      packet.received_count += 1
+      TelemetryTopic.write_packet(packet, scope: scope)
     end
 
     # Override the current value table such that a particular item always
@@ -188,7 +190,7 @@ module Cosmos
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
       topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-      msg_id, msg_hash = Store.instance.read_topic_last(topic)
+      msg_id, msg_hash = Topic.get_newest_message(topic)
       if msg_id
         msg_hash['buffer'] = msg_hash['buffer'].b
         return msg_hash
@@ -245,7 +247,17 @@ module Cosmos
     # @return [Array<Hash>] Array of all telemetry packet hashes
     def get_all_telemetry(target_name, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'tlm', target_name: target_name, scope: scope, token: token)
-      TargetModel.packets(target_name, scope: scope)
+      TargetModel.packets(target_name, type: :TLM, scope: scope)
+    end
+
+    # Returns an array of all telemetry packet's name and descriptions
+    #
+    # @since 5.0.3
+    # @param target_name [String] Name of the target
+    # @return [Array<Hash>] Array of all telemetry packet name and descriptions
+    def get_all_telemetry_list(target_name, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', target_name: target_name, scope: scope, token: token)
+      TargetModel.all_packet_name_descriptions(target_name, type: :TLM, scope: scope)
     end
 
     # Returns a telemetry packet hash
@@ -271,41 +283,53 @@ module Cosmos
       TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
     end
 
+    # 2x double underscore since __ is reserved
+    SUBSCRIPTION_DELIMITER = '____'
+
     # Subscribe to a list of packets. An ID is returned which is passed to
-    # get_packet(id) to yield packets back to a block.
+    # get_packets(id) to return packets.
     #
     # @param packets [Array<Array<String, String>>] Array of arrays consisting of target name, packet name
-    # @return [String] ID which should be passed to get_packet
+    # @return [String] ID which should be passed to get_packets
     def subscribe_packets(packets, scope: $cosmos_scope, token: $cosmos_token)
       if !packets.is_a?(Array) || !packets[0].is_a?(Array)
         raise ArgumentError, "packets must be nested array: [['TGT','PKT'],...]"
       end
 
-      result = [Time.now.to_nsec_from_epoch]
+      result = {}
       packets.each do |target_name, packet_name|
         authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
-        result << "#{scope}__DECOM__{#{target_name}}__#{packet_name}"
+        topic = "#{scope}__DECOM__{#{target_name}}__#{packet_name}"
+        id, _ = Topic.get_newest_message(topic)
+        result[topic] = id ? id : '0-0'
       end
-      result.join("\n")
+      result.to_a.join(SUBSCRIPTION_DELIMITER)
     end
     # Alias the singular as well since that matches COSMOS 4
     alias subscribe_packet subscribe_packets
 
-    # Get a packet which was previously subscribed to by subscribe_packet.
-    # This method takes a block and yields back packet hashes.
-    def get_packet(id, scope: $cosmos_scope, token: $cosmos_token)
+    # Get packets based on ID returned from subscribe_packet.
+    # @param id [String] ID returned from subscribe_packets or last call to get_packets
+    # @param block [Integer] Number of milliseconds to block when requesting packets
+    # @param count [Integer] Maximum number of packets to return from EACH packet stream
+    # @return [Array<String, Array<Hash>] Array of the ID and array of all packets found
+    def get_packets(id, block: nil, count: 1000, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'tlm', scope: scope, token: token)
-      offset, *topics = id.split("\n")
-      offsets = []
-      # Create a common array of offsets for each of the topics
-      topics.length.times do
-        offsets << (offset.to_i / 1_000_000).to_s + '-0'
-      end
-      Topic.read_topics(topics, offsets) do |topic, msg_id, msg_hash, redis|
-        json_hash = JSON.parse(msg_hash['json_data'])
-        msg_hash.delete('json_data')
-        yield msg_hash.merge(json_hash)
+      # Split the list of topic, ID values and turn it into a hash for easy updates
+      lookup = Hash[*id.split(SUBSCRIPTION_DELIMITER)]
+      xread = Topic.read_topics(lookup.keys, lookup.values, block, count)
+      # Return the original ID and nil if we didn't get anything
+      return [id, nil] if xread.empty?
+      packets = []
+      xread.each do |topic, data|
+        data.each do |id, msg_hash|
+          lookup[topic] = id # save the new ID
+          json_hash = JSON.parse(msg_hash['json_data'])
+          msg_hash.delete('json_data')
+          packets << msg_hash.merge(json_hash)
+        end
       end
+      return [lookup.to_a.join(SUBSCRIPTION_DELIMITER), packets]
     end
 
     # Get the receive count for a telemetry packet
@@ -316,7 +340,7 @@ module Cosmos
     def get_tlm_cnt(target_name, packet_name, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'system', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
-      _get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
+      Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
     end
 
     # Get information on all telemetry packets
@@ -329,14 +353,14 @@ module Cosmos
         TargetModel.packets(target_name, scope: scope).each do | packet |
           packet_name = packet['packet_name']
           key = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-          result << [target_name, packet_name, _get_cnt(key)]
+          result << [target_name, packet_name, Topic.get_cnt(key)]
         end
       end
       ['UNKNOWN'].each do | x |
         key = "#{scope}__TELEMETRY__{#{x}}__#{x}"
-        result << [x, x, _get_cnt(key)]
+        result << [x, x, Topic.get_cnt(key)]
       end
-      # Return the results sorted by target, packet
+      # Return the result sorted by target, packet
       result.sort_by { |a| [a[0], a[1]] }
     end
 
@@ -358,10 +382,14 @@ module Cosmos
       # Request the path by calling the key method. Returns something like this:
       # DEFAULT/decom_logs/tlm/INST2/MECH/20220104/20220104165449021942700__20220104170449148642700__DEFAULT__INST2__MECH__rt__decom.bin
       # Thus we split and take the start date/time part of the filename
-      start = list[0].key.split('/')[-1].split('__')[0]
-      # Format as YYYY-MM-DD HH:MM:SS for use by the frontend
-      # utc_time = Time.utc(start[0,4], start[4,2], start[6,2], start[8,2], start[10,2], start[12,2])
-      return "#{start[0,4]}-#{start[4,2]}-#{start[6,2]} #{start[8,2]}:#{start[10,2]}:#{start[12,2]}"
+      if list and list[0]
+        start = list[0].key.split('/')[-1].split('__')[0]
+        # Format as YYYY-MM-DD HH:MM:SS for use by the frontend
+        # utc_time = Time.utc(start[0,4], start[4,2], start[6,2], start[8,2], start[10,2], start[12,2])
+        return "#{start[0,4]}-#{start[4,2]}-#{start[6,2]} #{start[8,2]}:#{start[10,2]}:#{start[12,2]}"
+      else
+        return Time.now.utc.to_s[0..18]
+      end
     end
 
     # PRIVATE
@@ -397,7 +425,7 @@ module Cosmos
         TargetModel.packets(target_name, scope: scope).each do |packet|
           item = packet['items'].find { |item| item['name'] == item_name }
           if item
-            _, msg_hash = Store.instance.get_oldest_message("#{scope}__DECOM__{#{target_name}}__#{packet['packet_name']}")
+            _, msg_hash = Topic.get_oldest_message("#{scope}__DECOM__{#{target_name}}__#{packet['packet_name']}")
             if msg_hash && msg_hash['time'] && msg_hash['time'].to_i > latest
               packet_name = packet['packet_name']
               latest = msg_hash['time'].to_i

data/lib/cosmos/config/config_parser.rb

@@ -168,7 +168,7 @@ module Cosmos
         path = File.join(File.dirname(@filename), template_name)
       end
       Cosmos.set_working_dir(File.dirname(path)) do
-        return ERB.new(File.read(path)).result(b)
+        return ERB.new(File.read(path), trim_mode: "-").result(b)
       end
     end
 
@@ -238,27 +238,24 @@ module Cosmos
       end
     end
 
-    # Verifies the indicated parameter(s) in the config don't start or end
-    # with an underscore and don't contain a double underscore. Raises an
-    # Error if they do.
+    # Verifies the indicated parameter in the config doesn't start or end
+    # with an underscore, doesn't contain a double underscore, doesn't contain
+    # spaces and doesn't start with a close bracket.
     #
-    # @param [Integer|Range<Integer>|Array<Integer>] indeces_to_check The
-    #   indeces of the parameters that must follow underscore rules
-    def verify_parameters_underscores(indeces_to_check, usage = "")
-      indeces_to_check = (1..@parameters.length) if indeces_to_check.nil?
-      indeces_to_check = [indeces_to_check] unless indeces_to_check.respond_to? 'each'
-
-      indeces_to_check.each do |index|
-        param = @parameters[index - 1]
-        if param.end_with? '_'
-          raise Error.new(self, "Parameter #{index} (#{@parameters[index - 1]}) for #{@keyword} cannot end with an underscore ('_').", usage, @url)
-        end
-        if param.include? '__'
-          raise Error.new(self, "Parameter #{index} (#{@parameters[index - 1]}) for #{@keyword} cannot contain a double underscore ('__').", usage, @url)
-        end
-        if param.include? ' '
-          raise Error.new(self, "Parameter #{index} (#{@parameters[index - 1]}) for #{@keyword} cannot contain a space (' ').", usage, @url)
-        end
+    # @param [Integer] index The index of the parameter to check
+    def verify_parameter_naming(index, usage = "")
+      param = @parameters[index - 1]
+      if param.end_with? '_'
+        raise Error.new(self, "Parameter #{index} (#{param}) for #{@keyword} cannot end with an underscore ('_').", usage, @url)
+      end
+      if param.include? '__'
+        raise Error.new(self, "Parameter #{index} (#{param}) for #{@keyword} cannot contain a double underscore ('__').", usage, @url)
+      end
+      if param.include? ' '
+        raise Error.new(self, "Parameter #{index} (#{param}) for #{@keyword} cannot contain a space (' ').", usage, @url)
+      end
+      if param.start_with?('}')
+        raise Error.new(self, "Parameter #{index} (#{param}) for #{@keyword} cannot start with a close bracket ('}').", usage, @url)
       end
     end
 
@@ -380,7 +377,7 @@ module Cosmos
         output = nil
         if run_erb
           Cosmos.set_working_dir(File.dirname(filename)) do
-            output = ERB.new(File.read(filename)).result(binding.set_variables(variables))
+            output = ERB.new(File.read(filename), trim_mode: "-").result(binding.set_variables(variables))
           end
         else
           output = File.read(filename)

data/lib/cosmos/config/meta_config_parser.rb

@@ -50,7 +50,7 @@ module Cosmos
 
       output = nil
       Cosmos.set_working_dir(File.dirname(path)) do
-        output = ERB.new(File.read(path)).result(binding)
+        output = ERB.new(File.read(path), trim_mode: "-").result(binding)
       end
       tf.write(output)
       tf.close

data/lib/cosmos/conversions/generic_conversion.rb

@@ -73,5 +73,5 @@ module Cosmos
     def as_json
       { 'class' => self.class.name.to_s, 'params' => [@code_to_eval, @converted_type, @converted_bit_size] }
     end
-  end # class GenericConversion
-end # module Cosmos
+  end
+end

data/lib/cosmos/conversions/polynomial_conversion.rb

@@ -29,13 +29,10 @@ module Cosmos
     # Initializes the conversion with the given polynomial coefficients. Sets
     # the converted_type to :FLOAT and the converted_bit_size to 64.
     #
-    # @param coeff_array [Array<Float>] The polynomial coefficients
-    def initialize(coeff_array)
+    # @param coeffs [Array<Float>] The polynomial coefficients
+    def initialize(*coeffs)
       super()
-      @coeffs = []
-      coeff_array.each do |coeff|
-        @coeffs << coeff.to_f
-      end
+      @coeffs = coeffs.map { |coeff| coeff.to_f }
       @converted_type = :FLOAT
       @converted_bit_size = 64
     end
@@ -84,5 +81,5 @@ module Cosmos
     def as_json
       { 'class' => self.class.name.to_s, 'params' => @coeffs }
     end
-  end # class PolynomialConversion
-end # module Cosmos
+  end
+end

data/lib/cosmos/conversions/segmented_polynomial_conversion.rb

@@ -23,6 +23,9 @@ module Cosmos
   # Segmented polynomial conversions consist of polynomial conversions that are
   # applied for a range of values.
   class SegmentedPolynomialConversion < Conversion
+    # @return [Array<Segment>] Segments which make up this conversion
+    attr_reader :segments
+
     # A polynomial conversion segment which applies the conversion from the
     # lower bound (inclusive) until another segment's lower bound is
     # encountered.
@@ -31,6 +34,7 @@ module Cosmos
       #   should apply. All values >= to this value will be converted using the
       #   given coefficients.
       attr_reader :lower_bound
+
       # @return [Array<Integer>] The polynomial coefficients
       attr_reader :coeffs
 
@@ -57,6 +61,14 @@ module Cosmos
         return other_segment.lower_bound <=> @lower_bound
       end
 
+      # Implement equality operator primarily for ease of testing
+      #
+      # @param segment [Segment] Other segment
+      def ==(other_segment)
+        @lower_bound == other_segment.lower_bound &&
+          @coeffs == other_segment.coeffs
+      end
+
       # Perform the polynomial conversion
       #
       # @param value [Numeric] The value to convert
@@ -71,9 +83,15 @@ module Cosmos
     end
 
     # Initialize the converted_type to :FLOAT and converted_bit_size to 64.
-    def initialize
+    #
+    # @param segments [Array] Array of segments typically generated by as_json
+    #   Format similar to the following: [[15, [3, 2]], [10, [1, 2]]]
+    #   Where each entry is an array with the first value as the lower_bound
+    #   and the other entry is an array of the coefficients for that segment.
+    def initialize(segments = [])
       super()
       @segments = []
+      segments.each { |lower_bound, coeffs| add_segment(lower_bound, *coeffs) }
       @converted_type = :FLOAT
       @converted_bit_size = 64
     end
@@ -95,9 +113,7 @@ module Cosmos
     def call(value, packet, buffer)
       # Try to find correct segment
       @segments.each do |segment|
-        if value >= segment.lower_bound
-          return segment.calculate(value)
-        end
+        return segment.calculate(value) if value >= segment.lower_bound
       end
 
       # Default to using segment with smallest lower_bound
@@ -112,7 +128,7 @@ module Cosmos
     # @return [String] The name of the class followed by a description of all
     #   the polynomial segments.
     def to_s
-      result = ""
+      result = ''
       count = 0
       @segments.each do |segment|
         result << "\n" if count > 0
@@ -136,7 +152,8 @@ module Cosmos
     def to_config(read_or_write)
       config = ''
       @segments.each do |segment|
-        config << "    SEG_POLY_#{read_or_write}_CONVERSION #{segment.lower_bound} #{segment.coeffs.join(' ')}\n"
+        config <<
+          "    SEG_POLY_#{read_or_write}_CONVERSION #{segment.lower_bound} #{segment.coeffs.join(' ')}\n"
       end
       config
     end
@@ -146,7 +163,7 @@ module Cosmos
       @segments.each do |segment|
         params << [segment.lower_bound, segment.coeffs]
       end
-      { 'class' => self.class.name.to_s, 'params' => params }
+      { 'class' => self.class.name.to_s, 'params' => [params] }
     end
-  end # class SegmentedPolynomialConversion
-end # module Cosmos
+  end
+end

data/lib/cosmos/io/json_drb.rb

@@ -269,7 +269,11 @@ module Cosmos
               response = JsonRpcSuccessResponse.new(result, request.id)
             end
           rescue Exception => error
-            Logger.error error.formatted
+            # Filter out the framework stack trace (rails, rack, puma etc)
+            lines = error.formatted.split("\n")
+            i = lines.find_index { |row| row.include?('actionpack') || row.include?('activesupport') }
+            Logger.error lines[0...i].join("\n")
+
             if request.id
               if NoMethodError === error
                 error_code = JsonRpcError::ErrorCode::METHOD_NOT_FOUND

data/lib/cosmos/logs/log_writer.rb

@@ -19,7 +19,7 @@
 
 require 'thread'
 require 'cosmos/config/config_parser'
-require 'cosmos/utilities/store'
+require 'cosmos/topics/topic'
 require 'cosmos/utilities/s3'
 
 module Cosmos
@@ -211,7 +211,7 @@ module Cosmos
             S3Utilities.move_log_file_to_s3(@filename, s3_key)
             # Now that the file is in S3, trim the Redis stream up until the previous file.
             # This keeps one file worth of data in Redis as a safety buffer
-            Cosmos::Store.trim_topic(@redis_topic, @previous_file_redis_offset) if @redis_topic and @previous_file_redis_offset
+            Topic.trim_topic(@redis_topic, @previous_file_redis_offset) if @redis_topic and @previous_file_redis_offset
             @previous_file_redis_offset = @last_offset
           rescue Exception => err
             Logger.instance.error "Error closing #{@filename} : #{err.formatted}"

data/lib/cosmos/microservices/cleanup_microservice.rb

@@ -17,50 +17,49 @@
 # enterprise edition license of COSMOS if purchased from the
 # copyright holder
 
+require 'cosmos/models/target_model'
 require 'cosmos/microservices/microservice'
 require 'cosmos/utilities/s3'
 
 module Cosmos
   class CleanupMicroservice < Microservice
     def run
-      # Update settings from config
-      @config['options'].each do |option|
-        case option[0].upcase
-        when 'SIZE' # Max size to use in S3 in bytes
-          @size = option[1].to_i
-        when 'DELAY' # Delay between size checks
-          @delay = option[1].to_i
-        when 'BUCKET' # Which bucket to monitor
-          @bucket = option[1]
-        when 'PREFIX' # Path into bucket to monitor
-          @prefix = option[1]
-        else
-          Logger.error("Unknown option passed to microservice #{@name}: #{option}")
-        end
-      end
-
-      raise "Microservice #{@name} not fully configured" unless @size and @delay and @bucket and @prefix
+      split_name = @name.split("__")
+      target_name = split_name[-1]
+      target = TargetModel.get_model(name: target_name, scope: @scope)
 
       rubys3_client = Aws::S3::Client.new
       while true
         break if @cancel_thread
 
         @state = 'GETTING_OBJECTS'
-        total_size, oldest_list = S3Utilities.get_total_size_and_oldest_list(@bucket, @prefix)
-        delete_items = []
-        oldest_list.each do |item|
-          break if total_size <= @size
-
-          delete_items << { :key => item.key }
-          total_size -= item.size
-        end
-        if delete_items.length > 0
-          @state = 'DELETING_OBJECTS'
-          rubys3_client.delete_objects({ bucket: @bucket, delete: { objects: delete_items } })
+        start_time = Time.now
+        [
+         ["#{@scope}/raw_logs/cmd/#{target_name}/", target.cmd_log_retain_time], 
+         ["#{@scope}/decom_logs/cmd/#{target_name}/", target.cmd_decom_log_retain_time], 
+         ["#{@scope}/raw_logs/tlm/#{target_name}/", target.tlm_log_retain_time], 
+         ["#{@scope}/decom_logs/tlm/#{target_name}/", target.tlm_decom_log_retain_time],
+         ["#{@scope}/reduced_minute_logs/tlm/#{target_name}/", target.reduced_minute_log_retain_time],
+         ["#{@scope}/reduced_hour_logs/tlm/#{target_name}/", target.reduced_hour_log_retain_time],
+         ["#{@scope}/reduced_day_logs/tlm/#{target_name}/", target.reduced_day_log_retain_time],
+        ].each do |prefix, retain_time|
+          next unless retain_time
+          time = start_time - retain_time
+          total_size, oldest_list = S3Utilities.list_files_before_time('logs', prefix, time)
+          delete_items = []
+          oldest_list.each do |item|
+            delete_items << { :key => item.key }
+          end
+          if delete_items.length > 0
+            @state = 'DELETING_OBJECTS'
+            rubys3_client.delete_objects({ bucket: 'logs', delete: { objects: delete_items } })
+            Logger.info("Deleted #{delete_items.length} #{target_name} log files")
+          end
         end
+
         @count += 1
         @state = 'SLEEPING'
-        break if @microservice_sleeper.sleep(@delay)
+        break if @microservice_sleeper.sleep(target.cleanup_poll_time)
       end
     end
   end

data/lib/cosmos/microservices/decom_microservice.rb

@@ -31,7 +31,7 @@ module Cosmos
 
     def initialize(*args)
       super(*args)
-      Store.update_topic_offsets(@topics)
+      Topic.update_topic_offsets(@topics)
       System.telemetry.limits_change_callback = method(:limits_change_callback)
     end
 

data/lib/cosmos/microservices/interface_microservice.rb

@@ -143,7 +143,6 @@ module Cosmos
             hazardous, hazardous_description = System.commands.cmd_pkt_hazardous?(command)
             # Return back the error, description, and the formatted command
             # This allows the error handler to simply re-send the command
-            # TODO: Should we set target_name, cmd_name, and cmd_params instead?
             next "HazardousError\n#{hazardous_description}\n#{System.commands.format(command)}" if hazardous
           end
 

data/lib/cosmos/microservices/microservice.rb

@@ -40,7 +40,7 @@ module Cosmos
     attr_accessor :scope
 
     def self.run
-      microservice = self.new(ARGV[0])
+      microservice = self.new(ENV['COSMOS_MICROSERVICE_NAME'])
       begin
         MicroserviceStatusModel.set(microservice.as_json, scope: microservice.scope)
         microservice.state = 'RUNNING'
@@ -52,7 +52,7 @@ module Cosmos
         else
           microservice.error = err
           microservice.state = 'DIED_ERROR'
-          Logger.fatal("Microservice #{ARGV[0]} dying from exception\n#{err.formatted}")
+          Logger.fatal("Microservice #{ENV['COSMOS_MICROSERVICE_NAME']} dying from exception\n#{err.formatted}")
         end
       ensure
         MicroserviceStatusModel.set(microservice.as_json, scope: microservice.scope)
@@ -75,7 +75,7 @@ module Cosmos
 
       @name = name
       split_name = name.split("__")
-      raise "Microservice names should be scope, type, and then name" if split_name.length != 3
+      raise "Name #{name} doesn't match convention of SCOPE__TYPE__NAME" if split_name.length != 3
 
       @scope = split_name[0]
       $cosmos_scope = @scope