openc3 7.4.1 → 7.5.1

data/lib/openc3/utilities/pypi_url.rb

@@ -18,6 +18,18 @@ module OpenC3
   class PypiUrl
     DEFAULT = 'https://pypi.org/simple'
 
+    # Turn a configured PyPI base URL (the pypi_url setting or PYPI_URL) into
+    # its simple index URL. Trailing slashes are dropped first, matching the
+    # ${PYPI_URL%/}/simple the image builds use, so https://mirror/ does not
+    # give https://mirror//simple and https://pypi.org/ still equals DEFAULT.
+    #
+    # @param base_url [String, nil] the configured base url
+    # @return [String, nil] the simple index url, or nil when base_url is nil
+    def self.index_url(base_url)
+      return nil if base_url.nil?
+      "#{base_url.sub(%r{/+\z}, '')}/simple"
+    end
+
     # Validate that a resolved pypi_url is an http(s) URL before it is handed to
     # pip. The value can come from a user-writable setting or ENV, so a malformed
     # or non-http value is rejected and replaced with the default rather than
@@ -35,5 +47,58 @@ module OpenC3
       Logger.error("Invalid pypi_url '#{pypi_url}' (#{e.message}); falling back to #{DEFAULT}")
       DEFAULT
     end
+
+    # Environment variable that opts a deployment into insecure (unverified TLS)
+    # connections to the pypi index host, for operators running a private index
+    # with a self-signed certificate. OPENC3_ prefixed like our other settings,
+    # and kept out of uv's own UV_* namespace (uv reads UV_INSECURE_HOST itself).
+    INSECURE_HOST_ENV = 'OPENC3_PYPI_ALLOW_INSECURE'
+
+    # Previous name for INSECURE_HOST_ENV, still honored so existing helm values
+    # and compose files keep working. It was named for pip's --trusted-host, but
+    # every install path goes through uv (openc3/bin/pipinstall is a uv pip
+    # install wrapper), so the flag it produces is uv's --allow-insecure-host.
+    DEPRECATED_INSECURE_HOST_ENV = 'PIP_ENABLE_TRUSTED_HOST'
+
+    # Build the argv array of index arguments shared by every uv invocation.
+    #
+    # --default-index rather than -i/--index-url: the latter is deprecated by uv
+    # on both `uv sync` and `uv pip install`. Note this only affects the index uv
+    # resolves against, so it has no effect on `uv sync --frozen`, where uv.lock
+    # already pins each package's registry and wheel URL.
+    #
+    # --allow-insecure-host rather than --trusted-host: --trusted-host is an
+    # undocumented uv alias, so use the real uv option.
+    #
+    # @param pypi_url [String] the resolved and validated pypi index url
+    # @return [Array<String>] arguments to append to a uv command line
+    def self.build_args(pypi_url)
+      args = ["--default-index", pypi_url]
+      # --default-index does not win on its own: uv searches a named index
+      # declared in the plugin's own [tool.uv].index table first, so a plugin
+      # can quietly resolve against its author's index instead of the one the
+      # operator configured. --no-config makes uv ignore that table. Gated on
+      # the operator having actually designated an index, because at the public
+      # default there is no operator policy to enforce and the plugin author's
+      # own index configuration is the only signal there is.
+      #
+      # This is half the story: a package pinned with [tool.uv].sources is
+      # project metadata that survives --no-config. openc3/bin/uvinstall and
+      # openc3/bin/pipinstall add --no-sources for that, on the commands where
+      # uv actually resolves.
+      args << "--no-config" if pypi_url != DEFAULT
+      if allow_insecure_host?
+        args += ["--allow-insecure-host", URI.parse(pypi_url).host]
+      end
+      args
+    end
+
+    # @return [Boolean] whether the deployment opted into insecure connections
+    #   to the pypi index host
+    def self.allow_insecure_host?
+      # Empty counts as unset: compose passes both names through as
+      # ${VAR:-}, so an unset .env entry arrives as an empty string.
+      !ENV[INSECURE_HOST_ENV].to_s.empty? || !ENV[DEPRECATED_INSECURE_HOST_ENV].to_s.empty?
+    end
   end
 end

data/lib/openc3/utilities/questdb_client.rb

@@ -77,8 +77,9 @@ module OpenC3
     end
 
     # Get or create a thread-local PG connection for the given db_shard with type mapping configured.
+    # The port defaults to OPENC3_TSDB_QUERY_PORT.
     # Returns the thread-local connection - callers should not close it.
-    def self.connection(db_shard: 0)
+    def self.connection(db_shard: 0, port: nil)
       conns = @thread_conns.value
       conn = conns[db_shard]
       if conn and not conn.finished?
@@ -91,7 +92,7 @@ module OpenC3
       end
       conn = PG::Connection.new(
         host: hostname_for_db_shard(db_shard),
-        port: ENV['OPENC3_TSDB_QUERY_PORT'],
+        port: port || ENV.fetch('OPENC3_TSDB_QUERY_PORT', nil),
         user: ENV['OPENC3_TSDB_USERNAME'],
         password: ENV['OPENC3_TSDB_PASSWORD'],
         dbname: 'qdb'
@@ -122,11 +123,12 @@ module OpenC3
     end
 
     # Health check - attempt to connect and immediately close.
+    # The port defaults to OPENC3_TSDB_QUERY_PORT.
     # Returns true if successful, raises on failure.
-    def self.check_connection(db_shard: 0)
+    def self.check_connection(db_shard: 0, port: nil)
       conn = PG::Connection.new(
         host: hostname_for_db_shard(db_shard),
-        port: ENV['OPENC3_TSDB_QUERY_PORT'],
+        port: port || ENV.fetch('OPENC3_TSDB_QUERY_PORT', nil),
         user: ENV['OPENC3_TSDB_USERNAME'],
         password: ENV['OPENC3_TSDB_PASSWORD'],
         dbname: 'qdb'
@@ -628,10 +630,44 @@ module OpenC3
       query += " LIMIT 1"
       result = query_with_retry(query, max_retries: 1, label: "table_has_data", db_shard: db_shard)
       result && result.ntuples > 0
-    rescue RuntimeError
+    rescue QuestDBError, RuntimeError
+      # A table which doesn't exist fails the query
       false
     end
 
+    # Return the telemetry packets which have a table. The TSDB microservice only
+    # creates tables for its initial packets so a packet added later has no table
+    # until it's received. If the table names can't be fetched assume they all exist.
+    #
+    # @param packets [Array<Array(String, String)>] [target_name, packet_name] pairs
+    # @return [Set<Array(String, String)>] The pairs which have a table
+    def self.tlm_packets_with_tables(packets, scope: "DEFAULT")
+      existing = Set.new
+      packets.group_by { |target_name, _| db_shard_for_target(target_name, scope: scope) }.each do |db_shard, shard_packets|
+        names = table_names(db_shard: db_shard)
+        shard_packets.each do |target_name, packet_name|
+          if names.nil? or names.include?(sanitize_table_name(target_name, packet_name, scope: scope).upcase)
+            existing << [target_name, packet_name]
+          end
+        end
+      end
+      existing
+    end
+
+    # Return the names of all tables in a single query. Used to avoid querying
+    # (and failing on) tables that were never created, e.g. commands that have
+    # never been sent, which is the common case for targets with thousands of packets.
+    # QuestDB table names are case insensitive so the names are upcased.
+    #
+    # @return [Set<String>, nil] Upcased table names, or nil if they cannot be queried
+    def self.table_names(db_shard: 0)
+      result = query_with_retry("SELECT table_name FROM tables()", max_retries: 1, label: "table names", db_shard: db_shard)
+      return nil unless result
+      result.values.each_with_object(Set.new) { |row, set| set << row[0].to_s.upcase }
+    rescue StandardError
+      nil
+    end
+
     # QuestDB column types that can be aggregated with min/max/avg/stddev.
     # Used by reduced queries to decide whether a converted (__C) column is
     # numeric or must fall back to the raw column (e.g. states stored as VARCHAR).
@@ -918,19 +954,23 @@ module OpenC3
     # Query historical telemetry data from QuestDB for a list of items.
     # Builds the SQL query, executes it, and decodes all results.
     # Supports cross-db_shard queries by grouping items by db_shard, executing
-    # separate queries per db_shard, and merging results positionally.
+    # separate queries per db_shard, and aligning the results by packet time.
     #
     # @param items [Array] Array of [target_name, packet_name, item_name, value_type, limits]
     #   item_name may be nil to indicate a placeholder (non-existent item)
     # @param start_time [String, Numeric] Start timestamp for the query
     # @param end_time [String, Numeric, nil] End timestamp, or nil for "latest single row"
     # @param scope [String] Scope name
+    # @param flatten [Boolean] Whether a single row result is returned as a flat array
     # @return [Array, Hash] Array of [value, limits_state] pairs per row, or {} if no results.
-    #   Single-row results return a flat array; multi-row results return array of arrays.
-    def self.tsdb_lookup(items, start_time:, end_time: nil, scope: "DEFAULT")
+    #   Single-row results return a flat array (unless flatten is false); multi-row results return array of arrays.
+    def self.tsdb_lookup(items, start_time:, end_time: nil, scope: "DEFAULT", flatten: true)
       # Every item is a placeholder for an item which doesn't exist, so there's
       # nothing to query. Return a single row of nil values, one per item.
-      return Array.new(items.length) { [nil, nil] } if items.all? { |item| item[2].nil? }
+      if items.all? { |item| item[2].nil? }
+        row = Array.new(items.length) { [nil, nil] }
+        return flatten ? row : [row]
+      end
 
       # Group items by db_shard number while preserving their original positions
       db_shard_groups = {} # db_shard => { positions: [], items: [] }
@@ -945,39 +985,95 @@ module OpenC3
       # Single-db_shard fast path (most common case)
       if db_shard_groups.length == 1
         db_shard, group = db_shard_groups.first
-        return tsdb_lookup_single_db_shard(group[:items], start_time: start_time, end_time: end_time, scope: scope, db_shard: db_shard)
+        return tsdb_lookup_single_db_shard(group[:items], start_time: start_time, end_time: end_time, scope: scope, db_shard: db_shard, flatten: flatten)
       end
 
-      # Cross-db_shard: execute per-db_shard queries (as arrays of rows) and merge results
-      db_shard_rows = {} # db_shard => rows
-      db_shard_groups.each do |db_shard, group|
-        result = tsdb_lookup_single_db_shard(group[:items], start_time: start_time, end_time: end_time, scope: scope, db_shard: db_shard, flatten: false)
-        db_shard_rows[db_shard] = result.is_a?(Array) ? result : []
-      end
+      # Cross-db_shard: a single query can't ASOF JOIN tables on different QuestDBs
+      tsdb_lookup_db_shards(items, db_shard_groups, start_time: start_time, end_time: end_time, scope: scope, flatten: flatten)
+    end
 
-      # Merge results positionally back into the original item order. Each db_shard
-      # may have different row counts so use the maximum row count and fill missing
-      # positions with [nil, nil]. If all db_shards returned empty, return empty.
-      max_rows = db_shard_rows.values.map(&:length).max
-      return {} if max_rows == 0
+    # Cross-db_shard lookup which matches the rows of a single db_shard ASOF JOIN.
+    # The packet of the first item drives the rows (like T0 in a single db_shard query) so
+    # its db_shard is queried as usual. Every packet on another db_shard is queried on its
+    # own and aligned to each driving row's packet time, using its last row at or before
+    # that time (like ASOF JOIN). Each packet is aligned independently and includes its
+    # last row before start_time, so its value carries forward like it would in ASOF JOIN.
+    def self.tsdb_lookup_db_shards(items, db_shard_groups, start_time:, end_time:, scope:, flatten: true)
+      driver = db_shard_for_target(items.find { |item| item[2] }[0], scope: scope)
+      driver_rows = tsdb_lookup_single_db_shard(db_shard_groups[driver][:items], start_time: start_time, end_time: end_time, scope: scope, db_shard: driver, flatten: false, with_time: true)
+      return {} if !driver_rows.is_a?(Array) or driver_rows.empty?
+
+      # The packet time in nanoseconds is the last value of each row
+      times = driver_rows.map { |row| row[-1][0] }
+
+      merged = driver_rows.map do |driver_row|
+        row = Array.new(items.length) { [nil, nil] }
+        db_shard_groups[driver][:positions].each_with_index do |orig_pos, db_shard_idx|
+          row[orig_pos] = driver_row[db_shard_idx] if driver_row[db_shard_idx]
+        end
+        row
+      end
 
-      merged = Array.new(max_rows) { Array.new(items.length) { [nil, nil] } }
       db_shard_groups.each do |db_shard, group|
-        db_shard_rows[db_shard].each_with_index do |row, row_num|
-          group[:positions].each_with_index do |orig_pos, db_shard_idx|
-            merged[row_num][orig_pos] = row[db_shard_idx] if row[db_shard_idx]
+        next if db_shard == driver
+
+        # Group the items by packet, leaving placeholders as nils
+        packets = {} # [target_name, packet_name] => { positions: [], items: [] }
+        group[:positions].zip(group[:items]).each do |orig_pos, item|
+          next unless item[2]
+
+          packet = (packets[[item[0], item[1]]] ||= { positions: [], items: [] })
+          packet[:positions] << orig_pos
+          packet[:items] << item
+        end
+
+        packets.each_value do |packet|
+          rows = tsdb_lookup_packet_rows(packet[:items], times, start_time: start_time, end_time: end_time, scope: scope, db_shard: db_shard)
+          index = -1 # Index of the last packet row at or before the driving row
+          times.each_with_index do |driver_time, row_num|
+            index += 1 while index + 1 < rows.length and rows[index + 1][-1][0] <= driver_time
+            next if index < 0
+
+            packet[:positions].each_with_index do |orig_pos, packet_idx|
+              merged[row_num][orig_pos] = rows[index][packet_idx] if rows[index][packet_idx]
+            end
           end
         end
       end
+
       # Match the single db_shard behavior of returning a flat array for a single row
-      return merged[0] if max_rows == 1
+      return merged[0] if flatten and merged.length == 1
+
       merged
     end
 
+    # Query the rows of a single packet needed to align it to the driving row times.
+    # Each row ends with its packet time in nanoseconds.
+    def self.tsdb_lookup_packet_rows(items, times, start_time:, end_time:, scope:, db_shard:)
+      if end_time
+        # The last row before start_time followed by the rows in the range
+        queries = [{ start_time: start_time }, { start_time: start_time, end_time: end_time }]
+      else
+        # The single driving row is before start_time so get the last row at or before it
+        queries = [{ start_time: nsec_to_iso(times[0]), inclusive: true }]
+      end
+      queries.flat_map do |query|
+        result = tsdb_lookup_single_db_shard(items, scope: scope, db_shard: db_shard, flatten: false, with_time: true, **query)
+        result.is_a?(Array) ? result : []
+      end
+    end
+
+    # Convert a nanosecond integer timestamp to an ISO 8601 string with nanosecond precision
+    def self.nsec_to_iso(nsec)
+      Time.at(nsec / 1_000_000_000, nsec % 1_000_000_000, :nsec).utc.strftime('%Y-%m-%dT%H:%M:%S.%9NZ')
+    end
+
     # Execute a tsdb_lookup query against a single db_shard.
     # This contains the original ASOF JOIN logic for items all on the same QuestDB instance.
     # When flatten is true a single row result is returned as a flat array rather than an array of rows.
-    def self.tsdb_lookup_single_db_shard(items, start_time:, end_time: nil, scope: "DEFAULT", db_shard: 0, flatten: true)
+    # When inclusive is true a query without an end_time returns the last row at or before start_time.
+    # When with_time is true each row ends with its packet time in nanoseconds.
+    def self.tsdb_lookup_single_db_shard(items, start_time:, end_time: nil, scope: "DEFAULT", db_shard: 0, flatten: true, inclusive: false, with_time: false)
       tables = {}
       names = []
       nil_count = 0
@@ -986,6 +1082,14 @@ module OpenC3
       calculated_items = {}
       needed_timestamps = {}
       current_position = 0
+      # Columns with the same name in different tables come back renamed by QuestDB
+      # (e.g. VALUE and VALUE_2) so alias every column and map it back when decoding
+      aliases = {}
+      add_column = lambda do |col_name|
+        alias_name = "__col#{aliases.length}"
+        aliases[alias_name] = col_name
+        names << "\"#{col_name}\" as #{alias_name}"
+      end
 
       items.each do |item|
         target_name, packet_name, orig_item_name, value_type, limits = item
@@ -1000,7 +1104,7 @@ module OpenC3
         index = tables.find_index {|k,_v| k == table_name }
 
         if STORED_TIMESTAMP_ITEMS.include?(orig_item_name)
-          names << "\"T#{index}.#{orig_item_name}\""
+          add_column.call("T#{index}.#{orig_item_name}")
           current_position += 1
           next
         end
@@ -1030,11 +1134,11 @@ module OpenC3
 
         suffix = column_suffix_for_value_type(value_type)
         col_name = "T#{index}.#{safe_item_name}#{suffix}"
-        names << "\"#{col_name}\""
+        add_column.call(col_name)
         item_types[col_name] = resolve_item_type(item_def, value_type)
         current_position += 1
         if limits
-          names << "\"T#{index}.#{safe_item_name}__L\""
+          add_column.call("T#{index}.#{safe_item_name}__L")
         end
       end
 
@@ -1049,6 +1153,7 @@ module OpenC3
           names << "T#{table_index}.#{ts_col} as T#{table_index}___ts_#{ts_col}"
         end
       end
+      names << "cast(T0.PACKET_TIMESECONDS as long) as __time" if with_time
 
       # Build the SQL query
       query = "SELECT #{names.join(", ")} FROM "
@@ -1061,7 +1166,7 @@ module OpenC3
       end
       query_params = []
       if start_time && !end_time
-        query += "WHERE T0.PACKET_TIMESECONDS < $1 LIMIT -1"
+        query += "WHERE T0.PACKET_TIMESECONDS #{inclusive ? '<=' : '<'} $1 LIMIT -1"
         query_params << start_time
       elsif start_time && end_time
         query += "WHERE T0.PACKET_TIMESECONDS >= $1 AND T0.PACKET_TIMESECONDS < $2"
@@ -1080,13 +1185,16 @@ module OpenC3
         row_index = 0
         row_timestamps = {}
         tuples.each do |tuple|
-          col_name = tuple[0]
+          col_name = aliases.fetch(tuple[0], tuple[0])
           col_value = tuple[1]
           if col_name.include?("__L")
             data[row_num][row_index - 1][1] = col_value
           elsif col_name =~ /^__nil/
             data[row_num][row_index] = [nil, nil]
             row_index += 1
+          elsif col_name == '__time'
+            data[row_num][row_index] = [Integer(col_value), nil]
+            row_index += 1
           elsif col_name =~ /^T(\d+)___ts_(.+)$/
             table_idx = $1.to_i
             ts_source = $2

data/lib/openc3/utilities/running_script.rb

@@ -112,16 +112,7 @@ module OpenC3
               RunningScript.instance.perform_pause
             else
               if method.to_s == 'open_bucket_dialog'
-                bucket = input['bucket']
-                path = input['path']
-                filename = input['filename']
-                # Path from bucket dialog already includes scope prefix (e.g. DEFAULT/targets/...)
-                # _get_storage_file prepends scope, so strip it from the path to avoid doubling
-                scope = RunningScript.instance.scope
-                path = path.sub(/\A#{Regexp.escape(scope)}\//, '')
-                file = _get_storage_file(path, bucket: bucket, scope: scope)
-                file.filename = filename
-                return file
+                return _get_bucket_dialog_file(input, scope: RunningScript.instance.scope)
               elsif (method.to_s.include?('open_file'))
                 files = input.map do |filename|
                   file = _get_storage_file("tmp/#{filename}", scope: RunningScript.instance.scope)
@@ -275,10 +266,19 @@ module OpenC3
 
       def goto(line_no_or_procedure_name, line_no = nil)
         if line_no.nil?
-          start(RunningScript.instance.current_filename, line_no: line_no_or_procedure_name, bind_variables: true, complete: true)
+          procedure_name = RunningScript.instance.current_filename
+          line_no = line_no_or_procedure_name
         else
-          start(line_no_or_procedure_name, line_no: line_no, bind_variables: true, complete: true)
+          procedure_name = line_no_or_procedure_name
         end
+        # goto typed at the debug prompt is evaluated on the thread that processes
+        # go/step/stop messages. Running the script there deadlocks at the next pause,
+        # so hand it to the run thread the same way the editor's goto does.
+        unless RunningScript.run_thread?
+          RunningScript.instance.execute_while_paused(procedure_name, line_no, nil, true)
+          return
+        end
+        start(procedure_name, line_no: line_no, bind_variables: true, complete: true)
       end
 
       # Require an additional ruby file
@@ -797,6 +797,10 @@ class RunningScript
     @@instance = value
   end
 
+  def self.run_thread?
+    Thread.current == @@run_thread
+  end
+
   def self.line_delay
     @@line_delay
   end
@@ -1103,9 +1107,10 @@ class RunningScript
     trace
   end
 
-  def execute_while_paused(filename, line_no = 1, end_line_no = nil)
+  # bind_variables of nil binds only when filename is the currently running file
+  def execute_while_paused(filename, line_no = 1, end_line_no = nil, bind_variables = nil)
     if @script_status.state == 'paused' or @script_status.state == 'error' or @script_status.state == 'breakpoint'
-      @execute_while_paused_info = { filename: filename, line_no: line_no, end_line_no: end_line_no }
+      @execute_while_paused_info = { filename: filename, line_no: line_no, end_line_no: end_line_no, bind_variables: bind_variables }
     else
       scriptrunner_puts("Cannot execute selection or goto unless script is paused, breakpoint, or in error state")
     end
@@ -1217,10 +1222,9 @@ class RunningScript
 
   def check_execute_while_paused
     if @execute_while_paused_info
-      if @script_status.current_filename == @execute_while_paused_info[:filename]
-        bind_variables = true
-      else
-        bind_variables = false
+      bind_variables = @execute_while_paused_info[:bind_variables]
+      if bind_variables.nil?
+        bind_variables = (@script_status.current_filename == @execute_while_paused_info[:filename])
       end
       if @execute_while_paused_info[:end_line_no]
         # Execute Selection While Paused

data/lib/openc3/utilities/secrets.rb

@@ -71,6 +71,11 @@ module OpenC3
       klass.new
     end
 
+    # snake_case alias to match the Python Secrets.get_client
+    def self.get_client # rubocop:disable Naming/AccessorMethodName
+      getClient()
+    end
+
     def keys(secret_store: nil, scope:)
       raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
     end

data/lib/openc3/utilities/store_autoload.rb

@@ -54,11 +54,20 @@ module OpenC3
     @@db_shard_cache_mutex = Mutex.new
     DB_SHARD_CACHE_TIMEOUT = 60 # seconds
 
+    # Maximum number of entries read_topics returns PER STREAM when the caller
+    # does not pass a count. XREAD without COUNT returns everything from the
+    # offset to the tail of the stream, which for a consumer that has fallen
+    # behind on a high-rate stream can be an enormous reply materialized in
+    # memory all at once. Callers loop on their offsets so a capped read simply
+    # continues on the next call.
+    READ_TOPICS_DEFAULT_COUNT = 1000
+
     # Mutex used to ensure that only one instance is created
     @@instance_mutex = Mutex.new
 
     attr_reader :redis_url
     attr_reader :redis_pool
+    attr_reader :db_shard
 
     # Look up the db_shard number for a target with a 1-minute cache.
     # Reads directly from Redis db_shard 0 to avoid circular deps with TargetModel.
@@ -116,6 +125,7 @@ module OpenC3
     end
 
     def initialize(pool_size = 10, db_shard: 0)
+      @db_shard = db_shard
       @redis_username = ENV.fetch('OPENC3_REDIS_USERNAME', nil)
       @redis_key = ENV.fetch('OPENC3_REDIS_PASSWORD', nil)
       hostname = ENV['OPENC3_REDIS_HOSTNAME'].to_s.gsub("SHARDNUM", db_shard.to_s)
@@ -225,8 +235,10 @@ module OpenC3
       return offsets
     end
 
+    # @param count [Integer] Maximum entries to return per stream. nil uses READ_TOPICS_DEFAULT_COUNT.
     def read_topics(topics, offsets = nil, timeout_ms = 1000, count = nil)
       return {} if topics.empty?
+      count ||= READ_TOPICS_DEFAULT_COUNT
       Thread.current[:topic_offsets] ||= {}
       topic_offsets = Thread.current[:topic_offsets]
       begin
@@ -264,13 +276,20 @@ module OpenC3
     # @option opts [String]  :id          the entry id, default value is `*`, it means auto generation,
     #   if `nil` id is passed it will be changed to `*`
     # @option opts [Integer] :maxlen      max length of entries, default value is `nil`, it means will grow forever
-    # @option opts [String] :approximate whether to add `~` modifier of maxlen or not, default value is 'true'
+    # @option opts [String] :approximate whether to add `~` modifier of maxlen or minid or not, default value is 'true'
+    # @option opts [String] :minid       trim entries with ids lower than this as part of the add (XADD MINID).
+    #   Cannot be combined with maxlen. See Topic.stream_safety_minid for the safety cap applied to target streams.
     #
     # @return [String] the entry id
-    def write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = 'true')
+    def write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = 'true', minid: nil)
       id = '*' if id.nil?
+      raise ArgumentError, "write_topic can't supply both maxlen and minid" if maxlen and minid
       @redis_pool.with do |redis|
-        return redis.xadd(topic, msg_hash, id: id, maxlen: maxlen, approximate: approximate)
+        if minid
+          return redis.xadd(topic, msg_hash, id: id, minid: minid, approximate: approximate)
+        else
+          return redis.xadd(topic, msg_hash, id: id, maxlen: maxlen, approximate: approximate)
+        end
       end
     end
 
@@ -297,7 +316,7 @@ module OpenC3
 
   class EphemeralStore < Store
     def initialize(pool_size = 10, db_shard: 0)
-      super(pool_size)
+      super(pool_size, db_shard: db_shard)
       hostname = ENV['OPENC3_REDIS_EPHEMERAL_HOSTNAME'].to_s.gsub("SHARDNUM", db_shard.to_s)
       @redis_url = "redis://#{hostname}:#{ENV.fetch('OPENC3_REDIS_EPHEMERAL_PORT', 6380)}"
       @redis_pool = StoreConnectionPool.new(size: pool_size) { build_redis() }

data/lib/openc3/utilities/store_queued.rb

@@ -24,20 +24,32 @@ module OpenC3
     # Mutex used to ensure that only one instance is created
     @@instance_mutex = Mutex.new
 
+    DEFAULT_UPDATE_INTERVAL = 1 # seconds
+
     # Get the singleton instance for the given db_shard
-    # Sets the update interval to 1 second by default
-    def self.instance(update_interval = 1, db_shard: 0) # seconds
+    # Uses the interval from set_update_interval_all_shards if not given
+    def self.instance(update_interval = nil, db_shard: 0)
       @instances ||= []
       the_instance = @instances[db_shard]
       return the_instance if the_instance
 
       @@instance_mutex.synchronize do
         @instances ||= []
-        @instances[db_shard] ||= self.new(update_interval, db_shard: db_shard)
+        @instances[db_shard] ||= self.new(update_interval || @update_interval || DEFAULT_UPDATE_INTERVAL, db_shard: db_shard)
         return @instances[db_shard]
       end
     end
 
+    # Set the update interval on every db_shard instance, including ones created later
+    def self.set_update_interval_all_shards(interval)
+      return unless interval > 0.0
+
+      @@instance_mutex.synchronize do
+        @update_interval = interval
+        (@instances || []).compact.each { |the_instance| the_instance.set_update_interval(interval) }
+      end
+    end
+
     # Delegate all unknown class methods to delegate to the instance (db_shard 0)
     def self.method_missing(message, *args, **kwargs, &)
       self.instance.public_send(message, *args, **kwargs, &)
@@ -49,6 +61,8 @@ module OpenC3
       @store = store_instance()
       # Queue to hold the store requests
       @store_queue = Queue.new
+      # Orders queueing against the final drain in shutdown
+      @shutdown_mutex = Mutex.new
       # Sleeper used to delay update thread
       @update_sleeper = Sleeper.new
 
@@ -102,11 +116,18 @@ module OpenC3
       @update_sleeper.cancel if @update_sleeper
       OpenC3.kill_thread(self, @update_thread) if @update_thread
       @update_thread = nil
-      # Drain the queue before shutdown
-      begin
-        process_queue()
-      rescue
-        # Best effort - Redis may already be unavailable during shutdown
+      # Nothing drains the queue once the thread is gone, so from here on write
+      # straight through rather than silently dropping whatever gets queued.
+      # Drain first and flip the flag last, under the mutex, so a direct write
+      # can't be overwritten by an older queued one and nothing is queued after
+      # the drain.
+      @shutdown_mutex.synchronize do
+        begin
+          process_queue()
+        rescue
+          # Best effort - Redis may already be unavailable during shutdown
+        end
+        @shutdown = true
       end
     end
 
@@ -114,7 +135,14 @@ module OpenC3
 
     # Record the message for pipelining by the thread
     def method_missing(message, *args, **kwargs, &block)
-      @store_queue.push(MessageStruct.new(message, args, kwargs, block))
+      # @shutdown never goes back to false, so once set the lock can be skipped
+      unless @shutdown
+        queued = @shutdown_mutex.synchronize do
+          @store_queue.push(MessageStruct.new(message, args, kwargs, block)) unless @shutdown
+        end
+        return queued if queued
+      end
+      @store.public_send(message, *args, **kwargs, &block)
     end
 
     # Returns the store we're working with