openc3 7.0.1 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36f12f777f56b7d64a19cfd89b8886352b6f0fb06bbda59d95d5643b8d4c71f6
-  data.tar.gz: 1ebffbb1399279e391a47dde42e6f8b9492be10b389c8e63d148aab402ee614c
+  metadata.gz: fa824943ce72cce586cdfe03c1a5a8395120801bd845174c25433a15bf986306
+  data.tar.gz: 620cc66576e14e7e696419e5be0b5704190452d29efc35a315a489099b20f82e
 SHA512:
-  metadata.gz: ee971acf5bfd378f5a238263b467385286997900bea7fe549b8458c707568fb3a2265b261ee8794601bd42db7d0c2e8a983cf3d81a52c0c5069b9be0b41c4966
-  data.tar.gz: 5ba0ea7fb684a6e3e029864289612975db9555d1754f30f65baf4cf3193208516ea74029bb889b4575014b7953c45990c7e515dcf8f43d292bf8fc844de15a6b
+  metadata.gz: 1f392d51b2e5870128a995aa9e5717f9a4ed3bf0b8f55952b9141ec34898406734a2a834cf18d09b78d6e82f5675c2c0f3269e2ef62964ec58f2b96b8933ce80
+  data.tar.gz: a92a073ff672da55a44b85b700cb5b6a908208e9a10ddcad77828f02de0f877c3db2252d7d93857ab5b65d55b39594dfc109d72028a82cbfeaa6e468878eef94

data/bin/openc3cli

@@ -45,7 +45,8 @@ require 'irb/completion'
 require 'digest'
 require 'argon2'
 
-$redis_url = "redis://#{ENV['OPENC3_REDIS_HOSTNAME']}:#{ENV['OPENC3_REDIS_PORT']}"
+$redis_shardnum = ENV['OPENC3_SHARDNUM'] || "0"
+$redis_url = "redis://#{ENV['OPENC3_REDIS_HOSTNAME'].to_s.gsub("SHARDNUM", $redis_shardnum)}:#{ENV['OPENC3_REDIS_PORT']}"
 
 ERROR_CODE = 1
 
@@ -1143,6 +1144,48 @@ if not ARGV[0].nil? # argument(s) given
     end
     cli_pkg_uninstall(ARGV[1], scope: ARGV[2])
 
+  when 'reingest'
+    # Internal command spawned by StorageController via ProcessManager so the
+    # reingest runs in its own process and System singleton resets cannot
+    # collide with the cmd-tlm-api Rails server.
+    if ARGV[1].nil? || ARGV[2].nil? || ARGV[1] == '--help' || ARGV[1] == '-h'
+      puts "Usage: cli reingest JOB_ID SCOPE"
+      exit(ARGV[1].nil? ? 1 : 0)
+    end
+    require 'openc3/utilities/reingest_job'
+    require 'openc3/models/reingest_job_model'
+    job_id = ARGV[1]
+    scope = ARGV[2]
+    job = OpenC3::ReingestJobModel.get_model(name: job_id, scope: scope)
+    if job.nil?
+      OpenC3::Logger.error("Reingest job #{job_id} not found in scope #{scope}")
+      exit(1)
+    end
+    begin
+      OpenC3::ReingestJob.new(
+        job_id: job_id,
+        files: job.files,
+        path: job.path,
+        bucket: job.bucket,
+        scope: scope,
+        target_version: job.target_version,
+      ).run
+    rescue Exception => e
+      # ReingestJob#run already marks Crashed for errors raised during the run.
+      # This catches failures from the constructor itself (or anything before
+      # run gets its rescue installed) so the model doesn't sit in Queued forever.
+      OpenC3::Logger.error("Reingest job #{job_id} crashed before run: #{e.formatted}")
+      begin
+        job.state = 'Crashed'
+        job.error = e.message
+        job.finished_at = Time.now.utc.iso8601
+        job.update
+      rescue => e2
+        OpenC3::Logger.error("Reingest job #{job_id} failed to mark Crashed: #{e2.message}")
+      end
+      exit(1)
+    end
+
   when 'generate'
     # To test against a local copy call this file from the root cosmos directory like this:
     # ruby -Iopenc3/lib openc3/bin/openc3cli generate ...
@@ -1390,8 +1433,9 @@ if not ARGV[0].nil? # argument(s) given
         end
       end
     end
-    # Unless explicitly disabled, ensure the tools bucket is public
-    unless ENV.fetch("OPENC3_NO_BUCKET_POLICY", false)
+    # Unless explicitly disabled, ensure the tools bucket is public.
+    # OPENC3_TOOLS_BUCKET_PRIVATE keeps the tools bucket private; the cmd-tlm-api proxies reads via ToolsController.
+    unless ENV.fetch("OPENC3_NO_BUCKET_POLICY", false) || ENV.fetch("OPENC3_TOOLS_BUCKET_PRIVATE", false)
       client.ensure_public(ENV['OPENC3_TOOLS_BUCKET'])
     end
     # Always ensure the scriptrunner policy is in place since it is required for script execution

data/data/config/item_modifiers.yaml

@@ -193,4 +193,4 @@ HIDDEN:
   description: This item will not appear in PacketViewer or Item Choosers.
     It also hides this item from appearing in the Script Runner popup helper
     when writing scripts. The item will also not be included in decom data.
-  since: 6.10.1
+  since: 6.10.0

data/data/config/microservice.yaml

@@ -168,11 +168,22 @@ MICROSERVICE:
       since: 6.0.0
       parameters:
         - name: Shard
-          required: false
+          required: true
           description: Shard number starting from 0
           values: \d+
       example: |
         SHARD 0
+    DB_SHARD:
+      summary: Shard for target database database if sharding Redis/TSDB
+      description: DB Shard. Only used if running multiple database shards typically in Kubernetes
+      since: 7.1.0
+      parameters:
+        - name: DB Shard
+          required: true
+          description: DB Shard number starting from 0
+          values: \d+
+      example: |
+        DB_SHARD 0
     STOPPED:
       summary: Initially creates the microservice in a stopped state (not enabled)
       since: 6.2.0

data/data/config/parameter_modifiers.yaml

@@ -82,14 +82,15 @@ WRITE_CONVERSION:
     [INST inst_cmds.txt](https://github.com/OpenC3/cosmos/blob/main/openc3-cosmos-init/plugins/packages/openc3-cosmos-demo/targets/INST/cmd_tlm/inst_cmds.txt)
     or [INST2 inst_cmds.txt](https://github.com/OpenC3/cosmos/blob/main/openc3-cosmos-init/plugins/packages/openc3-cosmos-demo/targets/INST2/cmd_tlm/inst_cmds.txt).
 
-    :::info Multiple write conversions on command parameters
+    :::info[Multiple write conversions on command parameters]
     When a command is built, each item gets written (and write conversions are run)
     to set the default value. Then items are written (again write conversions are run)
     with user provided values. Thus write conversions can be run twice. Also there are
     no guarantees which parameters have already been written. The packet itself has a
-    given_values() method which can be used to retrieve a hash of the user provided
+    `given_values` attribute which can be used to retrieve a hash of the user provided
     values to the command. That can be used to check parameter values passed in.
     :::
+
   parameters:
     - name: Class Filename
       required: true
@@ -105,9 +106,48 @@ WRITE_CONVERSION:
         to the class constructor.
       values: .*
   ruby_example: |
-    WRITE_CONVERSION ip_write_conversion.rb
+    # Example command with a WRITE_CONVERSION that sets a command parameter
+    # based on the given values of other parameters
+    COMMAND INST BLOCK BIG_ENDIAN "Send variable block of data"
+      APPEND_PARAMETER BYTE 8 UINT MIN MAX 0x55 "Byte to duplicate"
+        FORMAT_STRING "0x%0X"
+      APPEND_PARAMETER LENGTH 32 UINT MIN MAX 0 "Length of data"
+      APPEND_PARAMETER DATA 0 BLOCK "" "Variable block of data"
+        WRITE_CONVERSION block_conversion.rb
+        HIDDEN # Because we're filling it in with a conversion
+
+    # Implemented in INST/lib/block_conversion.rb:
+    require 'openc3/conversions/conversion'
+    module OpenC3
+      class BlockConversion < Conversion
+        def call(value, packet, buffer)
+          # Use the packet.given_values hash to access user provided values to the command
+          byte = packet.given_values['BYTE'] || 0x55
+          length = packet.given_values['LENGTH'] || 0
+          [byte].pack('C') * length
+        end
+      end
+    end
   python_example: |
-    WRITE_CONVERSION openc3/conversions/ip_write_conversion.py
+    # Example command with a WRITE_CONVERSION that sets a command parameter
+    # based on the given values of other parameters
+    COMMAND INST BLOCK BIG_ENDIAN "Send variable block of data"
+      APPEND_PARAMETER BYTE 8 UINT MIN MAX 0x55 "Byte to duplicate"
+        FORMAT_STRING "0x%0X"
+      APPEND_PARAMETER LENGTH 32 UINT MIN MAX 0 "Length of data"
+      APPEND_PARAMETER DATA 0 BLOCK "" "Variable block of data"
+        WRITE_CONVERSION block_conversion.py
+        HIDDEN # Because we're filling it in with a conversion
+
+    # Implemented in INST/lib/block_conversion.py:
+    from openc3.conversions.conversion import Conversion
+    class BlockConversion(Conversion):
+        def call(self, value, packet, buffer):
+            # Use the packet.given_values hash to access user provided values to the command
+            byte = packet.given_values.get('BYTE', 0x55)
+            length = packet.given_values.get('LENGTH', 0)
+            return bytes([byte]) * length
+
 POLY_WRITE_CONVERSION:
   summary: Adds a polynomial conversion factor to the current command parameter
   description: See [Polynomial Conversion](/docs/configuration/conversions#polynomial_conversion) for more information.
@@ -127,14 +167,15 @@ GENERIC_WRITE_CONVERSION_START:
     value. The GENERIC_WRITE_CONVERSION_END keyword specifies that all lines of
     code for the conversion have been given.
 
-    :::info Multiple write conversions on command parameters
+    :::info[Multiple write conversions on command parameters]
     When a command is built, each item gets written (and write conversions are run)
     to set the default value. Then items are written (again write conversions are run)
     with user provided values. Thus write conversions can be run twice. Also there are
     no guarantees which parameters have already been written. The packet itself has a
-    given_values() method which can be used to retrieve a hash of the user provided
+    `given_values` attribute which can be used to retrieve a hash of the user provided
     values to the command. That can be used to check parameter values passed in.
     :::
+
   warning: Generic conversions are not a good long term solution. Consider creating
     a conversion class and using WRITE_CONVERSION instead. WRITE_CONVERSION is easier
     to debug and higher performance.
@@ -171,4 +212,5 @@ HIDDEN:
   summary: Hides this parameter from all the OpenC3 tools
   description: This item will not appear in CmdSender.
     It also hides this item from appearing in the Script Runner popup helper
-    when writing scripts. The parameter should not be provided to commands.
+    when writing scripts. The parameter should not be provided to commands.
+  since: 6.10.0

data/data/config/target.yaml

@@ -159,3 +159,14 @@ TARGET:
           values: \d+
       example: |
         SHARD 0
+    DB_SHARD:
+      summary: Shard for target database database if sharding Redis/TSDB
+      description: DB Shard. Only used if running multiple database shards typically in Kubernetes
+      since: 7.1.0
+      parameters:
+        - name: DB Shard
+          required: true
+          description: DB Shard number starting from 0
+          values: \d+
+      example: |
+        DB_SHARD 0

data/data/config/target_config.yaml

@@ -2,8 +2,12 @@
 LANGUAGE:
   summary: Programming language of the target interfaces and microservices
   description: The target language must be either Ruby or Python. The language
-    determines how the target's interfaces and microservices are run. Note that
-    both Ruby and Python still use ERB to perform templating.
+    determines how the target's interfaces and microservices are run. A target
+    must pick one language for its interfaces and microservices — you cannot
+    mix Ruby and Python interfaces/microservices within the same target. Scripts
+    executed in Script Runner are independent of this setting and may be written
+    in either Ruby or Python regardless of the target's LANGUAGE. Note that both
+    Ruby and Python still use ERB to perform templating.
   example: LANGUAGE python
   parameters:
     - language: Programming language

data/lib/openc3/api/cmd_api.rb

@@ -183,7 +183,8 @@ module OpenC3
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       topic = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
-      msg_id, msg_hash = Topic.get_newest_message(topic)
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
+      msg_id, msg_hash = Topic.get_newest_message(topic, db_shard: db_shard)
       if msg_id
         msg_hash['buffer'] = msg_hash['buffer'].b
         return msg_hash

data/lib/openc3/api/metrics_api.rb

@@ -28,9 +28,11 @@ module OpenC3
     DELAY_METRICS['log_topic_delta_seconds'] = 0.0
     DELAY_METRICS['router_topic_delta_seconds'] = 0.0
     DELAY_METRICS['text_log_topic_delta_seconds'] = 0.0
+    DELAY_METRICS['tsdb_ingest_topic_delta_seconds'] = 0.0
 
     DURATION_METRICS = {}
     DURATION_METRICS['decom_duration_seconds'] = 0.0
+    DURATION_METRICS['tsdb_ingest_duration_seconds'] = 0.0
 
     SUM_METRICS = {}
     SUM_METRICS['cleanup_total'] = 0
@@ -48,6 +50,8 @@ module OpenC3
     SUM_METRICS['router_directive_total'] = 0
     SUM_METRICS['text_log_total'] = 0
     SUM_METRICS['text_log_error_total'] = 0
+    SUM_METRICS['tsdb_ingest_total'] = 0
+    SUM_METRICS['tsdb_ingest_error_total'] = 0
 
     def get_metrics(manual: false, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'system', manual: manual, scope: scope, token: token)
@@ -79,7 +83,13 @@ module OpenC3
       result.merge!(duration_metrics)
       result.merge!(sum_metrics)
 
-      result.merge!(MetricModel.redis_metrics)
+      redis_metrics = MetricModel.redis_metrics
+      redis_metrics.each do |_db_shard, values|
+        values.each do |key, value|
+          existing = result[key]
+          result[key] = value if existing.nil? or value > existing
+        end
+      end
 
       return result
     end

data/lib/openc3/api/tlm_api.rb

@@ -117,7 +117,7 @@ module OpenC3
     # @param packet_name [String] Packet name of the packet
     # @param item_hash [Hash] Hash of item_name and value for each item you want to change from the current value table
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED
-    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, manual: false, scope: $openc3_scope, token: $openc3_token)
+    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, stored: false, manual: false, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       type = type.to_s.intern
       target_name = target_name.upcase
@@ -155,9 +155,9 @@ module OpenC3
 
       # Use an interface microservice if it exists, other use the decom microservice
       if interface_name
-        InterfaceTopic.inject_tlm(interface_name, target_name, packet_name, item_hash, type: type, scope: scope)
+        InterfaceTopic.inject_tlm(interface_name, target_name, packet_name, item_hash, type: type, stored: stored, scope: scope)
       else
-        DecomInterfaceTopic.inject_tlm(target_name, packet_name, item_hash, type: type, scope: scope)
+        DecomInterfaceTopic.inject_tlm(target_name, packet_name, item_hash, type: type, stored: stored, scope: scope)
       end
     end
 
@@ -221,7 +221,8 @@ module OpenC3
         return msg_hash
       else
         topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-        msg_id, msg_hash = Topic.get_newest_message(topic)
+        db_shard = Store.db_shard_for_target(target_name, scope: scope)
+        msg_id, msg_hash = Topic.get_newest_message(topic, db_shard: db_shard)
         if msg_id
           msg_hash['buffer'] = msg_hash['buffer'].b
           return msg_hash
@@ -446,7 +447,8 @@ module OpenC3
         packet_name = packet_name.upcase
         authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
         topic = "#{scope}__DECOM__{#{target_name}}__#{packet_name}"
-        id, _ = Topic.get_newest_message(topic)
+        db_shard = Store.db_shard_for_target(target_name, scope: scope)
+        id, = Topic.get_newest_message(topic, db_shard: db_shard)
         results[topic] = id ? id : '0-0'
       end
       results.to_a.join(SUBSCRIPTION_DELIMITER)
@@ -463,7 +465,20 @@ module OpenC3
       authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       # 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, nil, count) # Always don't block
+      # Group topics by db_shard for multi-shard support
+      db_shard_groups = {}
+      lookup.each do |topic, offset|
+        target_name = topic.match(/__\{?([^}_]+)\}?__/)[1] rescue nil
+        db_shard = Store.db_shard_for_target(target_name, scope: scope)
+        db_shard_groups[db_shard] ||= { topics: [], offsets: [] }
+        db_shard_groups[db_shard][:topics] << topic
+        db_shard_groups[db_shard][:offsets] << offset
+      end
+      xread = {}
+      db_shard_groups.each do |db_shard, group|
+        result = Topic.read_topics(group[:topics], group[:offsets], nil, count, db_shard: db_shard) # Always don't block
+        xread.merge!(result) if result
+      end
       # Return the original ID and and empty array if we didn't get anything
       packets = []
       return [id, packets] if xread.empty?

data/lib/openc3/core_ext/faraday.rb

@@ -1,6 +1,6 @@
 # Remove warnings in CGI
 saved_verbose = $VERBOSE
-$VERBOSE = false
+$VERBOSE = nil
 require 'faraday'
 $VERBOSE = saved_verbose
 

data/lib/openc3/io/json_api.rb

@@ -65,7 +65,7 @@ module OpenC3
 
     def _request(*method_params, **kw_params)
       kw_params[:scope] = $openc3_scope unless kw_params[:scope]
-      kw_params[:json] = true unless kw_params[:json]
+      kw_params[:json] = true # This is JsonApi so should always be speaking json
       @json_api.request(*method_params, **kw_params)
     end
   end

data/lib/openc3/logs/log_writer.rb

@@ -237,7 +237,9 @@ module OpenC3
                   # Now that the file is in S3, trim the Redis stream up until the previous file.
                   # This keeps one minute of data in Redis
                   instance.cleanup_offsets[index].each do |redis_topic, cleanup_offset|
-                    Topic.trim_topic(redis_topic, cleanup_offset)
+                    target_match = redis_topic.match(/__\{?([^}_]+)\}?__/)
+                    db_shard = target_match ? Store.db_shard_for_target(target_match[1]) : 0
+                    Topic.trim_topic(redis_topic, cleanup_offset, db_shard: db_shard)
                   end
                   indexes_to_clear << index
                 end

data/lib/openc3/microservices/decom_common.rb

@@ -0,0 +1,128 @@
+# encoding: ascii-8bit
+
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/system/system'
+require 'openc3/microservices/interface_microservice'
+require 'openc3/topics/telemetry_decom_topic'
+require 'openc3/models/target_model'
+
+module OpenC3
+  # Shared decom pipeline used by DecomMicroservice (live telemetry) and
+  # ReingestJob (historical raw log replay). The reingest path passes
+  # check_limits: false so historical data does not re-fire limits events.
+  module DecomCommon
+    extend self
+
+    # Decommutate a Packet and publish it on the TelemetryDecomTopic. This is the
+    # step that lands data in the CVT and in the Python TsdbMicroservice → QuestDB.
+    #
+    # @param packet [Packet] A fully buffered Packet. Caller sets received_time,
+    #   received_count, stored, extra, buffer.
+    # @param scope [String] Scope name.
+    # @param target_names [Array<String>] Used when a subpacket must be re-identified.
+    # @param logger [Logger] Destination for warnings.
+    # @param name [String] Identifier used in subpacket warning messages
+    #   (microservice name, or "REINGEST:<job_id>").
+    # @param check_limits [Boolean] When false, skips the Packet#check_limits call.
+    #   Reingest passes false so historical data does not re-fire limits events.
+    # @param metric [Metric, nil] Optional; when set, records decom_duration_seconds.
+    # @param error_callback [Proc, nil] Called as error_callback.call(exception) when
+    #   Packet#process or Packet#check_limits raises. The microservice uses this to
+    #   bump its decom_error_total metric.
+    # @return [Integer] Number of (sub)packets published.
+    def decom_and_publish(packet, scope:, target_names:, logger:, name:,
+                          check_limits: true, metric: nil, error_callback: nil)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC) if metric
+      published = 0
+
+      packet_and_subpackets = packet.subpacketize
+      packet_and_subpackets.each do |packet_or_subpacket|
+        if packet_or_subpacket.subpacket
+          packet_or_subpacket = handle_subpacket(packet, packet_or_subpacket,
+                                                 target_names: target_names,
+                                                 scope: scope,
+                                                 logger: logger,
+                                                 name: name)
+        end
+
+        begin
+          packet_or_subpacket.process
+        rescue Exception => e
+          error_callback&.call(e)
+          logger.error e.message
+        end
+
+        packet_or_subpacket.check_limits(System.limits_set) if check_limits
+
+        TelemetryDecomTopic.write_packet(packet_or_subpacket, scope: scope)
+        published += 1
+      end
+
+      if metric
+        diff = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        metric.set(name: 'decom_duration_seconds', value: diff, type: 'gauge', unit: 'seconds')
+      end
+
+      published
+    end
+
+    # Identify a subpacket and (except for stored telemetry) update the CVT.
+    # Extracted from DecomMicroservice so reingest can handle subpackets too.
+    def handle_subpacket(packet, subpacket, target_names:, scope:, logger:, name:)
+      subpacket.received_time = packet.received_time
+      subpacket.stored = packet.stored
+      subpacket.extra = packet.extra
+
+      if subpacket.stored
+        identified_subpacket = System.telemetry.identify_and_define_packet(subpacket, target_names, subpackets: true)
+      else
+        if subpacket.identified?
+          begin
+            identified_subpacket = System.telemetry.update!(subpacket.target_name,
+                                                            subpacket.packet_name,
+                                                            subpacket.buffer)
+          rescue RuntimeError
+            logger.warn "#{name}: Received unknown identified subpacket: #{subpacket.target_name} #{subpacket.packet_name}"
+            subpacket.target_name = nil
+            subpacket.packet_name = nil
+            identified_subpacket = System.telemetry.identify!(subpacket.buffer,
+                                                              target_names, subpackets: true)
+          end
+        else
+          identified_subpacket = System.telemetry.identify!(subpacket.buffer,
+                                                            target_names, subpackets: true)
+        end
+      end
+
+      if identified_subpacket
+        identified_subpacket.received_time = subpacket.received_time
+        identified_subpacket.stored = subpacket.stored
+        identified_subpacket.extra = subpacket.extra
+        subpacket = identified_subpacket
+      else
+        unknown_subpacket = System.telemetry.update!('UNKNOWN', 'UNKNOWN', subpacket.buffer)
+        unknown_subpacket.received_time = subpacket.received_time
+        unknown_subpacket.stored = subpacket.stored
+        unknown_subpacket.extra = subpacket.extra
+        subpacket = unknown_subpacket
+        num_bytes_to_print = [InterfaceMicroservice::UNKNOWN_BYTES_TO_PRINT, subpacket.length].min
+        data = subpacket.buffer(false)[0..(num_bytes_to_print - 1)]
+        prefix = data.each_byte.map { |byte| sprintf("%02X", byte) }.join()
+        logger.warn "#{name} #{subpacket.target_name} packet length: #{subpacket.length} starting with: #{prefix}"
+      end
+
+      TargetModel.sync_tlm_packet_counts(subpacket, target_names, scope: scope)
+      subpacket
+    end
+  end
+end