openc3 7.5.0 → 7.5.1

data/lib/openc3/script/extract.rb

@@ -195,7 +195,8 @@ module OpenC3
     end
 
     # Splits `check()` comparison expressions, e.g. "== 'foo bar'" becomes ["==", "foo bar"]
-    def extract_operator_and_operand_from_comparison(comparison)
+    # The optional block resolves an unquoted word, see extract_operand
+    def extract_operator_and_operand_from_comparison(comparison, &resolve_name)
       operator, operand = comparison.split(nil, 2) # Ruby: second split arg is max number of resultant elements
 
       if operand.nil?
@@ -207,7 +208,7 @@ module OpenC3
       raise "ERROR: Invalid operator: '#{operator}'" unless COMPARISON_OPERATORS.include?(operator)
 
       # split leaves any trailing whitespace on the operand which the anchored matches reject
-      operand = extract_operand(operand.strip)
+      operand = extract_operand(operand.strip, &resolve_name)
       # 'in' is containment against a list of values in both Ruby and Python.
       # Enforced here so check(), wait() and wait_check() all reject the same thing.
       if operator == "in" and !operand.is_a?(Array)
@@ -219,7 +220,9 @@ module OpenC3
 
     # Converts the operand of a `check()` comparison expression into a Ruby value.
     # Note this deliberately does not eval the operand so only literal values are supported.
-    def extract_operand(operand)
+    # The optional block is called with an unquoted word, including one inside a list, and
+    # returns the value to use or nil if the word is not recognized, e.g. a state name.
+    def extract_operand(operand, &resolve_name)
       # A quoted operand must be a single complete string literal. Anything trailing the
       # closing quote, e.g. "== 'a' garbage 'b'", is a syntax error rather than a string.
       if (match = operand.match(/\A'((?:[^'\\]|\\.)*)'\z/m))
@@ -248,7 +251,7 @@ module OpenC3
       # Arrays are parsed recursively so their elements follow exactly the same rules as a
       # bare operand. JSON alone would reject ['ON', 'OFF'], [0xA, 0xB] and [true, nil].
       if operand.start_with?('[') and operand.end_with?(']')
-        return split_operand_list(operand[1..-2]).map { |element| extract_operand(element) }
+        return split_operand_list(operand[1..-2]).map { |element| extract_operand(element, &resolve_name) }
       end
       # JSON handles decimal numbers and hashes
       begin
@@ -272,7 +275,10 @@ module OpenC3
 
       # A bare word is almost always a string the user forgot to quote
       if operand.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
-        raise NameError, "Uninitialized constant #{operand}. Did you mean '#{operand}' as a string?"
+        value = resolve_name&.call(operand)
+        return value unless value.nil?
+
+        raise NameError, "Unknown state name #{operand}. Did you mean '#{operand}' as a string?"
       end
       raise "ERROR: Unable to parse operand: #{operand}"
     end
@@ -369,6 +375,47 @@ module OpenC3
       return elements
     end
 
+    # Splits a comparison like extract_operator_and_operand_from_comparison but matches state names.
+    # State names are stored upper case so a string operand which matches a state name ignoring case
+    # is compared against that state name, e.g. "== 'Connected'" matches the CONNECTED state.
+    # An unquoted state name, e.g. "== Connected" or "in [On, Off]", is also accepted. The block returns
+    # the item hash. It is only called once, when the operand could be a state name, so numeric
+    # comparisons don't make an additional API call. RAW values are never state names so it is never called.
+    def extract_comparison(comparison, value_type, &get_item)
+      item_states = nil
+      looked_up = false
+      states = lambda do
+        unless looked_up
+          looked_up = true
+          item_states = get_item.call['states'] unless value_type.to_s.upcase == 'RAW'
+        end
+        item_states
+      end
+      operator, operand = extract_operator_and_operand_from_comparison(comparison) do |name|
+        name.upcase if states.call&.key?(name.upcase)
+      end
+      return [operator, operand] unless operand_contains_string?(operand)
+
+      return [operator, states.call ? upcase_state_names(operand, states.call) : operand]
+    end
+
+    # Returns whether the operand is or contains a string, i.e. could be a state name
+    def operand_contains_string?(operand)
+      return true if operand.is_a?(String)
+      return operand.any? { |element| operand_contains_string?(element) } if operand.is_a?(Array)
+      return false
+    end
+
+    # State names are stored upper case so any string in the operand which matches
+    # a state name ignoring case is replaced with that state name
+    def upcase_state_names(operand, states)
+      if operand.is_a?(String)
+        return states.key?(operand.upcase) ? operand.upcase : operand
+      end
+      return operand.map { |element| upcase_state_names(element, states) } if operand.is_a?(Array)
+      return operand
+    end
+
     # Compares a telemetry value against an operand using the given operator.
     # Returns false rather than raising if the two values can not be compared.
     def compare_values(value, operator, operand)

data/lib/openc3/script/script.rb

@@ -313,7 +313,7 @@ module OpenC3
           return disconnect if disconnect
           # The only commands allowed through in disconnect mode are read-only
           # Thus we allow the get, list, tlm and limits_enabled and subscribe methods
-          if method_name =~ /\w*_get$|^get_\w*|\w*_list$|^list_\w*|^tlm|^limits_enabled$|^subscribe$/
+          if method_name =~ /\w*_get$|^get_\w*|\w*_list$|^list_\w*|^tlm|^limits_enabled\??$|^subscribe$/
             return @json_drb.method_missing(method_name, *method_params, **kw_params)
           else
             return nil

data/lib/openc3/topics/limits_event_topic.rb

@@ -25,6 +25,20 @@ module OpenC3
   # While this isn't a clean separation of topics (streams) and models (key-value)
   # it helps maintain consistency as the topic and model are linked.
   class LimitsEventTopic < Topic
+    # Returns the items in a limits group grouped by target and packet, or nil if the
+    # group is undefined. Reads the store directly to avoid a circular reference to TargetModel.
+    # @return [Hash{String => Hash{String => Array<String>}}, nil]
+    def self.limits_group_items(group_name, scope:)
+      json = Store.hget("#{scope}__limits_groups", group_name)
+      return nil unless json
+
+      items = {}
+      JSON.parse(json, allow_nan: true, create_additions: true).each do |target_name, packet_name, item_name|
+        ((items[target_name] ||= {})[packet_name] ||= []) << item_name
+      end
+      items
+    end
+
     # Collect all unique target db_shards from TargetModel
     def self._active_db_shards(scope:)
       db_shards = Set.new([0])
@@ -85,6 +99,30 @@ module OpenC3
         limits_settings['enabled'] = event[:enabled]
         Store.hset("#{scope}__current_limits_settings", field, JSON.generate(limits_settings, allow_nan: true))
 
+      when :LIMITS_GROUP_ENABLE_STATE
+        # Groups can contain many thousands of items so read and write the settings in bulk
+        fields = []
+        (limits_group_items(event[:group_name], scope: scope) || {}).each do |target_name, packets|
+          packets.each do |packet_name, item_names|
+            item_names.each { |item_name| fields << "#{target_name}__#{packet_name}__#{item_name}" }
+          end
+        end
+        unless fields.empty?
+          all_settings = Store.hmget("#{scope}__current_limits_settings", *fields)
+          updates = {}
+          fields.each_with_index do |field, index|
+            limits_settings = all_settings[index]
+            if limits_settings
+              limits_settings = JSON.parse(limits_settings, allow_nan: true, create_additions: true)
+            else
+              limits_settings = {}
+            end
+            limits_settings['enabled'] = event[:enabled]
+            updates[field] = JSON.generate(limits_settings, allow_nan: true)
+          end
+          Store.hmset("#{scope}__current_limits_settings", *updates.flatten)
+        end
+
       when :LIMITS_STATE_COLOR
         # Persist the state color so it survives a decom microservice restart (applied by sync_system)
         field = "#{event[:target_name]}__#{event[:packet_name]}__#{event[:item_name]}"
@@ -111,8 +149,9 @@ module OpenC3
       end
 
       # Write to all active db_shards so each decom microservice can read limits events inline
+      msg_hash = { event: JSON.generate(event, allow_nan: true) }
       _active_db_shards(scope: scope).each do |db_shard|
-        Topic.write_topic("#{scope}__openc3_limits_events", {event: JSON.generate(event, allow_nan: true)}, '*', 1000, db_shard: db_shard)
+        Topic.write_topic("#{scope}__openc3_limits_events", msg_hash, '*', 1000, db_shard: db_shard)
       end
     end
 
@@ -214,6 +253,26 @@ module OpenC3
       Store.hdel("#{scope}__limits_sets", set_name)
     end
 
+    # Returns true if limits events written after previous_id were trimmed from the
+    # stream before they were read. The stream keeps ~1000 entries so a flood of
+    # LIMITS_CHANGE events can trim events a slow reader hasn't processed yet.
+    # Stream IDs always increase, so if the oldest remaining entry is newer than the
+    # last entry read, the entries in between are gone. This can also report a gap
+    # when only previous_id itself was trimmed, which just causes an extra resync.
+    def self.events_trimmed?(previous_id, scope:, db_shard: 0)
+      # 0-0 means the stream was empty when the reader started
+      return false if previous_id.nil? or previous_id == '0-0'
+      oldest_id = Topic.get_oldest_message("#{scope}__openc3_limits_events", db_shard: db_shard)&.first
+      return false unless oldest_id
+      (oldest_id.split('-').map(&:to_i) <=> previous_id.split('-').map(&:to_i)) > 0
+    end
+
+    # Reload all limits state from the store, used to recover from missed limits events
+    def self.resync_system(scope:)
+      System.limits_set = current_set(scope: scope)
+      sync_system(scope: scope)
+    end
+
     # Update the local System based on overall state
     def self.sync_system(scope:)
       all_limits_settings = Store.hgetall("#{scope}__current_limits_settings")
@@ -251,7 +310,7 @@ module OpenC3
 
     # Process a single limits event hash and update the local System accordingly.
     # Called inline by DecomMicroservice when reading from the limits events topic.
-    def self.process_event(event, telemetry: nil)
+    def self.process_event(event, scope:, telemetry: nil)
       telemetry ||= System.telemetry.all
       case event['type']
       when 'LIMITS_CHANGE'
@@ -289,6 +348,34 @@ module OpenC3
           end
         end
 
+      when 'LIMITS_GROUP_ENABLE_STATE'
+        enabled = ConfigParser.handle_true_false_nil(event['enabled'])
+        (limits_group_items(event['group_name'], scope: scope) || {}).each do |target_name, packets|
+          target = telemetry[target_name]
+          next unless target
+
+          packets.each do |packet_name, item_names|
+            packet = target[packet_name]
+            next unless packet
+
+            item_names.each do |item_name|
+              next unless packet.items[item_name]
+
+              # The stream offset has already advanced past this event so isolate
+              # failures to a single item rather than skipping the rest of the group
+              begin
+                if enabled
+                  System.limits.enable(target_name, packet_name, item_name)
+                else
+                  System.limits.disable(target_name, packet_name, item_name)
+                end
+              rescue => e
+                Logger.error("Error #{enabled ? 'enabling' : 'disabling'} limits for #{target_name} #{packet_name} #{item_name}: #{e.formatted}")
+              end
+            end
+          end
+        end
+
       when 'LIMITS_STATE_COLOR'
         target_name = event['target_name']
         packet_name = event['packet_name']
@@ -313,7 +400,7 @@ module OpenC3
       topics = ["#{scope}__openc3_limits_events"]
       Topic.read_topics(topics, nil, block_ms) do |_topic, _msg_id, event, _redis|
         event = JSON.parse(event['event'], allow_nan: true, create_additions: true)
-        process_event(event, telemetry: telemetry)
+        process_event(event, scope: scope, telemetry: telemetry)
       end
     end
   end

data/lib/openc3/topics/router_topic.rb

@@ -78,14 +78,18 @@ module OpenC3
       end
     end
 
+    # Write to the target's db_shard where its interface reads commands
     def self.route_command(packet, target_names, scope:)
+      # Write to the target's db_shard where its interface reads commands
       if packet.identified?
         topic = "{#{scope}__CMD}TARGET__#{packet.target_name}"
-        Topic.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => packet.packet_name, 'cmd_buffer' => packet.buffer(false) }, '*', 100)
+        db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
+        Topic.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => packet.packet_name, 'cmd_buffer' => packet.buffer(false) }, '*', 100, db_shard: db_shard)
       elsif target_names.length == 1
         topic = "{#{scope}__CMD}TARGET__#{target_names[0]}"
+        db_shard = Store.db_shard_for_target(target_names[0], scope: scope)
         # Name the routed target so the interface identifies against it (and sends it as UNKNOWN if that fails)
-        Topic.write_topic(topic, { 'target_name' => target_names[0], 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100)
+        Topic.write_topic(topic, { 'target_name' => target_names[0], 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100, db_shard: db_shard)
       else
         raise "No route for command: #{packet.target_name ? packet.target_name : 'UNKNOWN'} #{packet.packet_name ? packet.packet_name : 'UNKNOWN'}"
       end

data/lib/openc3/topics/system_events_topic.rb

@@ -17,14 +17,17 @@ module OpenC3
   class SystemEventsTopic < Topic
     PRIMARY_KEY = "OPENC3__SYSTEM__EVENTS".freeze
 
-    # Collect all unique target db_shards from TargetModel
+    # Collect all unique target and interface db_shards. Interfaces read system
+    # events on their own db_shard which may not have any targets on it.
     def self._active_db_shards
       db_shards = Set.new([0])
-      # Iterate all scopes to find all target db_shards
-      Store.scan_each(match: '*__openc3_targets', type: 'hash') do |key|
-        Store.hgetall(key).each do |_name, json|
-          parsed = JSON.parse(json, allow_nan: true, create_additions: true)
-          db_shards << (parsed['db_shard'] || 0).to_i
+      # Iterate all scopes to find all target and interface db_shards
+      ['*__openc3_targets', '*__openc3_interfaces'].each do |match|
+        Store.scan_each(match: match, type: 'hash') do |key|
+          Store.hgetall(key).each do |_name, json|
+            parsed = JSON.parse(json, allow_nan: true, create_additions: true)
+            db_shards << (parsed['db_shard'] || 0).to_i
+          end
         end
       end
       db_shards

data/lib/openc3/topics/topic.rb

@@ -221,6 +221,13 @@ module OpenC3
       EphemeralStore.instance(db_shard: db_shard).del(topic)
     end
 
+    # Extract the target name from the {TARGET} hash tag in a topic like
+    # DEFAULT__TELEMETRY__{INST}__HEALTH_STATUS. Returns nil if there is none.
+    def self.target_name_from_topic(topic)
+      match = topic.match(/__\{([^}]+)\}__/)
+      match ? match[1] : nil
+    end
+
     # Group topics by db_shard. Each topic's target name is extracted and looked up.
     # Topics matching target_pattern are db_sharded; others go to db_shard 0.
     # @param topics [Array<String>] List of topic strings
@@ -231,7 +238,7 @@ module OpenC3
       groups = {}
       topics.each do |topic|
         if topic.include?(target_pattern)
-          target_name = topic.match(/__\{?([^}_]+)\}?__/)[1] rescue nil
+          target_name = target_name_from_topic(topic)
           # Handle CMD}TARGET__ pattern where target is after TARGET__
           target_name = topic.split('TARGET__')[1] if target_pattern.include?('TARGET__') && target_name.nil?
           db_shard = (Store.db_shard_for_target(target_name, scope: scope) || 0).to_i

data/lib/openc3/utilities/bucket.rb

@@ -28,6 +28,11 @@ module OpenC3
       klass.new
     end
 
+    # snake_case alias to match the Python Bucket.get_client
+    def self.get_client # rubocop:disable Naming/AccessorMethodName
+      getClient()
+    end
+
     def initialize
       # Setup the client instance
     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,30 @@ 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.
@@ -932,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: [] }
@@ -959,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
@@ -1000,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
@@ -1014,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
@@ -1044,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
 
@@ -1063,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 "
@@ -1075,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"
@@ -1094,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/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

@@ -67,6 +67,7 @@ module OpenC3
 
     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.
@@ -124,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)
@@ -314,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() }