openc3 7.2.0 → 7.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90e17f6bf28158ea786646171220e3c23aca07cce30559b3e64a29f83dabb50d
-  data.tar.gz: 9a13e73273ba67e7d6003a9578a34a8b1c0abadea3b8d4d369f1fd3803a4f0ec
+  metadata.gz: 13ecd5ed69a40943e0ceb4732af0922106d73ba3e28c7e10521e3cbcbb2728c9
+  data.tar.gz: e8a55a75e964de92cdc8fa9a27091d472437004a0775a05c894d4a16d5232677
 SHA512:
-  metadata.gz: eec5ccdb945747570717e5f60f9a89158d500d994f1fa5e6ebc81ed8bb263229950f10e1f277e0c68bf5d9fb531f3470354d45fda2164f7608c9ad22413b2022
-  data.tar.gz: a32f7675eacf6b41b345a4b5ae554292db011499d12a9e5e65173c514e5fac7e66da3bacea7ad5cf9a3738fcb96e3a82009997993fc70722d4a9ba4edd236261
+  metadata.gz: 77c7ed5bcae0862bf8d7ccdeefbc79cdc814b04501831e5de5a2b7b1d685420f731da2bb230435a1d091697156ab1d58a40cf793869da48e191b7c87ccbffea9
+  data.tar.gz: 90571e3012ae117610314df3d32d67d77a843f2de8edb2c9b51bab3335cf0618e7301a9ba0c55616acad6a2d0ca1b4634924531f657bd438c0fd490aeca6a327

data/bin/openc3cli

@@ -671,30 +671,18 @@ def cli_script_list(args, options)
 end
 
 def parse_suite_runner_options(options)
-  suite_runner = nil
   # suite must be given to enable Suite Runner execution
-  if options[:suite]
-    suite_runner = {}
-    suite_runner['suite'] = options[:suite]
-    if options[:group]
-      suite_runner['group'] = options[:group]
-      # script requires group to be set
-      if options[:script]
-        suite_runner['script'] = options[:script]
-      end
-    end
-    if options[:method]
-      suite_runner['method'] = options[:method]
-    else
-      suite_runner['method'] = 'start'
-    end
-    if options[:options]
-      suite_runner['options'] = options[:options].split(',')
-    else
-      suite_runner['options'] = ["continueAfterError"]
-    end
-  end
-  return suite_runner
+  return nil unless options[:suite]
+  require 'openc3/script/suite_runner'
+  # Build the canonical hash via the shared helper so the CLI applies the same
+  # shape, defaults, and validation (e.g. script requires group) as execution.
+  return OpenC3::SuiteRunner.build_options(
+    suite: options[:suite],
+    group: options[:group],
+    script: options[:script],
+    method: options[:method],
+    options: options[:options]&.split(','),
+  )
 end
 
 def cli_script_run(args, options)

data/data/config/interface_modifiers.yaml

@@ -1,11 +1,16 @@
 ---
 MAP_TARGET:
   summary: Maps a target name to an interface
+  description: See [Mapping Targets to Interfaces](/docs/configuration/interfaces#mapping-targets-to-interfaces) for more information.
   parameters:
     - name: Target Name
       required: true
       description: Target name to map to this interface
       values: .+
+    - name: Enabled State
+      required: false
+      description: Initial enabled state of the target on this interface. Defaults to ENABLED.
+      values: ["ENABLED", "DISABLED"]
   ruby_example: |
     INTERFACE DATA_INT tcpip_client_interface.rb host.docker.internal 8080 8081 10.0 nil BURST
       MAP_TARGET DATA
@@ -14,12 +19,17 @@ MAP_TARGET:
       MAP_TARGET DATA
 MAP_CMD_TARGET:
   summary: Maps a target name to an interface for commands only
+  description: See [Mapping Targets to Interfaces](/docs/configuration/interfaces#mapping-targets-to-interfaces) for more information.
   since: 5.2.0
   parameters:
     - name: Target Name
       required: true
       description: Command target name to map to this interface
       values: .+
+    - name: Enabled State
+      required: false
+      description: Initial enabled state of the command target on this interface. Defaults to ENABLED.
+      values: ["ENABLED", "DISABLED"]
   ruby_example: |
     INTERFACE CMD_INT tcpip_client_interface.rb host.docker.internal 8080 8081 10.0 nil BURST
       MAP_CMD_TARGET DATA # Only DATA commands go on the CMD_INT interface
@@ -28,12 +38,17 @@ MAP_CMD_TARGET:
       MAP_CMD_TARGET DATA # Only DATA commands go on the CMD_INT interface
 MAP_TLM_TARGET:
   summary: Maps a target name to an interface for telemetry only
+  description: See [Mapping Targets to Interfaces](/docs/configuration/interfaces#mapping-targets-to-interfaces) for more information.
   since: 5.2.0
   parameters:
     - name: Target Name
       required: true
       description: Telemetry target name to map to this interface
       values: .+
+    - name: Enabled State
+      required: false
+      description: Initial enabled state of the telemetry target on this interface. Defaults to ENABLED.
+      values: ["ENABLED", "DISABLED"]
   ruby_example: |
     INTERFACE TLM_INT tcpip_client_interface.rb host.docker.internal 8080 8081 10.0 nil BURST
       MAP_TLM_TARGET DATA # Only DATA telemetry received on TLM_INT interface

data/data/config/target.yaml

@@ -170,3 +170,20 @@ TARGET:
           values: \d+
       example: |
         DB_SHARD 0
+    STORED_LIMITS_MODE:
+      summary: Controls how limits are evaluated for stored (non-real-time) telemetry packets
+      description:
+        Sets the limits handling policy for packets where the stored flag is true
+        (e.g., packets from file interfaces or historical data replay).
+        PROCESS processes limits normally including logging and reactions.
+        LOG evaluates limits and logs state changes but does not trigger limits reactions
+        or update the current limits state used by the API.
+        DISABLE skips limits processing entirely for stored packets.
+      since: 7.2.1
+      parameters:
+        - name: Mode
+          required: true
+          description: "PROCESS (default), LOG, or DISABLE"
+          values: ^(PROCESS|LOG|DISABLE)$
+      example: |
+        STORED_LIMITS_MODE DISABLE

data/data/config/widgets.yaml

@@ -1579,7 +1579,10 @@ Canvas Widgets:
   collection:
     CANVAS:
       summary: Layout widget for the other canvas widgets
-      description: All canvas widgets must be enclosed within a CANVAS widget.
+      description:
+        All canvas widgets must be enclosed within a CANVAS widget.
+        The canvas background defaults to white. Use SETTING BACKCOLOR to set a
+        different background color.
       warning: The canvas coordinate frame places (0,0) in the upper-left corner of the canvas.
       parameters:
         - name: Width
@@ -1590,6 +1593,30 @@ Canvas Widgets:
           required: true
           description: Height of the canvas
           values: .+
+      settings:
+        BACKCOLOR:
+          summary: Sets the background color of the canvas
+          since: 7.2.1
+          parameters:
+            - name: Color name or Red value
+              required: true
+              description: Common name for the color, e.g. 'black', 'red', etc.
+                Alternatively if two more parameters are passed this is the
+                Red value of the RGB value
+              values: .+
+            - name: Green value
+              required: false
+              description: Green value of the RGB value
+              values: .+
+            - name: Blue value
+              required: false
+              description: Blue value of the RGB value
+              values: .+
+      example: |
+        CANVAS 100 50
+          SETTING BACKCOLOR 17 21 28
+          CANVASLABEL 5 30 "Dark canvas" 18 white
+        END
     CANVASLABEL:
       summary: Draws text onto the canvas
       parameters:

data/lib/openc3/accessors/binary_accessor.rb

@@ -108,6 +108,10 @@ module OpenC3
 
     def handle_read_variable_bit_size(item, _buffer)
       length_value = @packet.read(item.variable_bit_size['length_item_name'], :CONVERTED)
+      # length_value can be nil when reading an undersized packet where the length
+      # item falls outside the buffer bounds
+      raise "Length value #{item.variable_bit_size['length_item_name']} for item #{item.name} is nil" if length_value.nil?
+
       if item.array_size
         item.array_size = (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
       else

data/lib/openc3/api/cmd_api.rb

@@ -450,7 +450,7 @@ module OpenC3
 
     # NOTE: When adding new keywords to this method, make sure to update script/commands.rb
     def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil, manual: false, validate: true, queue: nil,
-                            scope: $openc3_scope, token: $openc3_token, **kwargs)
+                            queue_username: nil, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       unless [nil, true, false].include?(log_message)
         raise "Invalid log_message parameter: #{log_message}. Must be true or false."
@@ -535,6 +535,10 @@ module OpenC3
         'log_message' => log_message.to_s,
         'obfuscated_items' => packet['obfuscated_items'].to_s
       }
+      # Record the original queuing user (author) separately from 'username' (the
+      # user or process that actually executed the command). Command History shows
+      # 'username' as "Executed By" and queue_username as "Queued By".
+      command['queue_username'] = queue_username if queue_username
       # Users have to explicitly opt into a default queue by setting the OPENC3_DEFAULT_QUEUE
       # At which point ALL commands will go to that queue unless they specifically opt out with queue: false
       if ENV['OPENC3_DEFAULT_QUEUE'] && queue.nil?

data/lib/openc3/api/limits_api.rb

@@ -17,6 +17,7 @@
 
 require 'openc3/api/target_api'
 require 'openc3/models/cvt_model'
+require 'openc3/packets/packet_item'
 
 module OpenC3
   module Api
@@ -29,12 +30,14 @@ module OpenC3
                        'disable_limits',
                        'get_limits',
                        'set_limits',
+                       'set_state_color',
                        'get_limits_groups',
                        'enable_limits_group',
                        'disable_limits_group',
                        'get_limits_sets',
                        'set_limits_set',
                        'get_limits_set',
+                       'delete_limits_set',
                        'get_limits_events',
                      ])
 
@@ -251,6 +254,50 @@ module OpenC3
       LimitsEventTopic.write(event, scope: scope)
     end
 
+    # Change the color associated with a telemetry item state in realtime.
+    # Items with states use the state color (GREEN, YELLOW, RED) to determine
+    # their limits state rather than numeric red/yellow/green limits.
+    #
+    # @param target_name [String] Target name
+    # @param packet_name [String] Packet name
+    # @param item_name [String] Item name
+    # @param state_name [String] Name of the state to change (e.g. 'CONNECTED')
+    # @param color [String] New color for the state. Must be GREEN, YELLOW, or RED.
+    def set_state_color(target_name, packet_name, item_name, state_name, color,
+                        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)
+      state_name = state_name.to_s.upcase
+      color = color.to_s.upcase
+      unless PacketItem::STATE_COLORS.include?(color.intern)
+        raise "Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}."
+      end
+      packet = TargetModel.packet(target_name, packet_name, scope: scope)
+      found_item = nil
+      packet['items'].each do |item|
+        if item['name'] == item_name
+          unless item['states'] && item['states'][state_name]
+            raise "State '#{state_name}' does not exist for item '#{target_name} #{packet_name} #{item_name}'"
+          end
+          item['states'][state_name]['color'] = color
+          # Defining a state color implies limits are enabled for the item
+          item['limits'] ||= {}
+          item['limits']['enabled'] = true
+          found_item = item
+          break
+        end
+      end
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+      message = "Setting '#{target_name} #{packet_name} #{item_name}' state #{state_name} color to #{color}"
+      Logger.info(message, scope: scope)
+
+      TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
+
+      event = { type: :LIMITS_STATE_COLOR, target_name: target_name, packet_name: packet_name,
+                item_name: item_name, state_name: state_name, color: color,
+                time_nsec: Time.now.to_nsec_from_epoch, message: message }
+      LimitsEventTopic.write(event, scope: scope)
+    end
+
     # Returns all limits_groups and their members
     # @since 5.0.0 Returns hash with values
     # @return [Hash{String => Array<Array<String, String, String>>]
@@ -292,6 +339,31 @@ module OpenC3
         time_nsec: Time.now.to_nsec_from_epoch, message: message }, scope: scope)
     end
 
+    # Deletes a limits set. The DEFAULT limits set and the currently active
+    # limits set cannot be deleted. Use set_limits_set to change the active set
+    # before deleting it. Note that the limits set is not removed from the
+    # TargetModel packet definitions; that is cleaned up on the next plugin
+    # install.
+    #
+    # @param limits_set [String] The name of the limits set to delete
+    def delete_limits_set(limits_set, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', manual: manual, scope: scope, token: token)
+      limits_set = limits_set.to_s
+      raise "Cannot delete the DEFAULT limits set" if limits_set == 'DEFAULT'
+      if limits_set == LimitsEventTopic.current_set(scope: scope)
+        raise "Cannot delete the current limits set '#{limits_set}'. Use set_limits_set to change the current set first."
+      end
+      unless LimitsEventTopic.sets(scope: scope).key?(limits_set)
+        raise "Limits set '#{limits_set}' does not exist"
+      end
+
+      # Remove the limits set from Redis (limits_sets and current_limits_settings)
+      LimitsEventTopic.delete_set(limits_set, scope: scope)
+
+      message = "Deleting Limits Set: #{limits_set}"
+      Logger.info(message, scope: scope)
+    end
+
     # Returns the active limits set that applies to all telemetry
     #
     # @return [String] The current limits set

data/lib/openc3/microservices/decom_common.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
@@ -35,13 +35,19 @@ module OpenC3
     #   (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 stored_limits_mode [String] Controls limits handling for stored packets.
+    #   'PROCESS' (default) processes limits normally.
+    #   'LOG' still evaluates limits (callback handles suppressing reactions).
+    #   'DISABLE' skips limits evaluation entirely for stored packets and omits
+    #   limits states from the decommutated output.
     # @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)
+                          check_limits: true, stored_limits_mode: 'PROCESS',
+                          metric: nil, error_callback: nil)
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC) if metric
       published = 0
 
@@ -62,9 +68,14 @@ module OpenC3
           logger.error e.message
         end
 
-        packet_or_subpacket.check_limits(System.limits_set) if check_limits
+        disable_stored_limits = packet_or_subpacket.stored && stored_limits_mode == 'DISABLE'
+        if check_limits && !disable_stored_limits
+          packet_or_subpacket.check_limits(System.limits_set)
+        end
 
-        TelemetryDecomTopic.write_packet(packet_or_subpacket, scope: scope)
+        TelemetryDecomTopic.write_packet(packet_or_subpacket,
+                                         include_limits_states: !disable_stored_limits,
+                                         scope: scope)
         published += 1
       end
 

data/lib/openc3/microservices/decom_microservice.rb

@@ -100,6 +100,8 @@ module OpenC3
       @limits_response_thread = nil
       System.telemetry.limits_change_callback = method(:limits_change_callback)
       LimitsEventTopic.sync_system(scope: @scope)
+      target_model = TargetModel.get_model(name: @target_names[0], scope: @scope)
+      @stored_limits_mode = target_model ? (target_model.stored_limits_mode || 'PROCESS') : 'PROCESS'
       @error_count = 0
       @metric.set(name: 'decom_total', value: @count, type: 'counter')
       @metric.set(name: 'decom_error_total', value: @error_count, type: 'counter')
@@ -184,6 +186,7 @@ module OpenC3
           logger: @logger,
           name: @name,
           check_limits: true,
+          stored_limits_mode: @stored_limits_mode,
           metric: @metric,
           error_callback: ->(e) {
             @error_count += 1
@@ -253,9 +256,11 @@ module OpenC3
       event = { type: :LIMITS_CHANGE, target_name: packet.target_name, packet_name: packet.packet_name,
                 item_name: item.name, old_limits_state: old_limits_state.to_s, new_limits_state: item.limits.state.to_s,
                 time_nsec: packet_time.to_nsec_from_epoch, message: message.to_s }
+      suppress_stored = packet.stored && @stored_limits_mode != 'PROCESS'
+      event[:suppress_stored] = true if suppress_stored
       LimitsEventTopic.write(event, scope: @scope)
 
-      if item.limits.response
+      if item.limits.response && !suppress_stored
         copied_packet = packet.deep_copy
         copied_item = packet.items[item.name]
         @limits_response_queue << [copied_packet, copied_item, old_limits_state]

data/lib/openc3/microservices/interface_microservice.rb

@@ -272,6 +272,11 @@ module OpenC3
               else
                 next nil # Don't ack disabled targets
               end
+            rescue RangeError => e
+              # Command parameter out of range is a user error, not a bug,
+              # so only log the message and not the full stack trace
+              @logger.error "#{@interface.name}: #{e.message}"
+              next e.message
             rescue => e
               @logger.error "#{@interface.name}: #{msg_hash}"
               @logger.error "#{@interface.name}: #{e.formatted}"
@@ -281,6 +286,9 @@ module OpenC3
             command.extra ||= {}
             command.extra['cmd_string'] = msg_hash['cmd_string']
             command.extra['username'] = msg_hash['username']
+            command.extra['interface_name'] = @interface.name
+            # Original author of a queued command (set when released from a queue)
+            command.extra['queue_username'] = msg_hash['queue_username'] if msg_hash['queue_username']
             # Add approver info if this was a critical command that was approved
             if critical_model
               command.extra['approver'] = critical_model.approver
@@ -706,16 +714,19 @@ module OpenC3
         # Try to do clean disconnect because we're going down
         disconnect(false)
       end
-      if @interface_or_router == 'INTERFACE'
-        InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
-      else
-        RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+      unless @cancel_thread
+        if @interface_or_router == 'INTERFACE'
+          InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+        else
+          RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+        end
       end
       @logger.info "#{@interface.name}: Stopped packet reading"
     end
 
     def handle_packet(packet)
-      InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+      # Skip status update if stop() has been called to avoid re-creating the status model
+      InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope) unless @cancel_thread
       packet.received_time = Time.now.sys unless packet.received_time
 
       if packet.stored
@@ -853,7 +864,8 @@ module OpenC3
 
       # If the interface is set to auto_reconnect then delay so the thread
       # can come back around and allow the interface a chance to reconnect.
-      if allow_reconnect and @interface.auto_reconnect and @interface.state != 'DISCONNECTED'
+      # Skip reconnect if stop() has been called to avoid re-creating the status model
+      if allow_reconnect and @interface.auto_reconnect and @interface.state != 'DISCONNECTED' and !@cancel_thread
         attempting()
         if !@cancel_thread
           # @logger.debug "reconnect delay: #{@interface.reconnect_delay}"
@@ -861,10 +873,12 @@ module OpenC3
         end
       else
         @interface.state = 'DISCONNECTED'
-        if @interface_or_router == 'INTERFACE'
-          InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
-        else
-          RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+        unless @cancel_thread
+          if @interface_or_router == 'INTERFACE'
+            InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+          else
+            RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+          end
         end
       end
     end
@@ -914,4 +928,4 @@ if __FILE__ == $0
   OpenC3::InterfaceMicroservice.run
   OpenC3::ThreadManager.instance.shutdown
   OpenC3::ThreadManager.instance.join
-end
+end

data/lib/openc3/microservices/queue_microservice.rb

@@ -76,12 +76,14 @@ module OpenC3
               end
               validate = command.key?('validate') ? command['validate'] : true
               timeout = command['timeout']
-              cmd(command['target_name'], command['cmd_name'], cmd_params, queue: false, validate: validate, timeout: timeout, scope: @scope)
+              # Pass queue_username so Command History is attributed to the original
+              # author rather than the queue microservice name
+              cmd(command['target_name'], command['cmd_name'], cmd_params, queue: false, validate: validate, timeout: timeout, queue_username: command['username'], scope: @scope)
             elsif command['value']
               # Legacy format: use single string parameter for backwards compatibility
               validate = command.key?('validate') ? command['validate'] : true
               timeout = command['timeout']
-              cmd(command['value'], queue: false, validate: validate, timeout: timeout, scope: @scope)
+              cmd(command['value'], queue: false, validate: validate, timeout: timeout, queue_username: command['username'], scope: @scope)
             else
               @logger.error "QueueProcessor: Invalid command format, missing required fields"
             end

data/lib/openc3/migrations/20260701000000_updated_at_to_int.rb

@@ -0,0 +1,55 @@
+# 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 'time'
+require 'openc3/utilities/migration'
+require 'openc3/core_ext/time'
+require 'openc3/models/scope_model'
+require 'openc3/models/script_status_model'
+
+module OpenC3
+  # Earlier versions of the Python script runner wrote the ScriptStatusModel
+  # updated_at field as an ISO8601 string (e.g. "2026-06-30T12:34:56.789012Z")
+  # instead of integer nanoseconds since the epoch. This migration rewrites any
+  # such string values as integers so updated_at is consistently an int.
+  #
+  # NOTE: The stored JSON is edited in place rather than reloaded through the
+  # model and re-created, because ScriptStatusModel#create always sets
+  # updated_at to the current time, which would discard the original timestamp.
+  class UpdatedAtToInt < Migration
+    def self.run
+      ScopeModel.names.each do |scope|
+        [ScriptStatusModel::RUNNING_PRIMARY_KEY, ScriptStatusModel::COMPLETED_PRIMARY_KEY].each do |key|
+          primary_key = "#{key}__#{scope}"
+          Store.hgetall(primary_key).each do |name, json|
+            data = JSON.parse(json, allow_nan: true)
+            updated_at = data['updated_at']
+            next unless updated_at.is_a?(String)
+
+            begin
+              data['updated_at'] = Time.parse(updated_at).to_nsec_from_epoch
+            rescue ArgumentError
+              # Leave unparsable values untouched
+              next
+            end
+            Store.hset(primary_key, name, JSON.generate(data, allow_nan: true))
+          end
+        end
+      end
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::UpdatedAtToInt.run
+end

data/lib/openc3/models/cvt_model.rb

@@ -26,8 +26,8 @@ module OpenC3
     @@override_cache = {}
 
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED]
-    def self.build_json_from_packet(packet)
-      packet.decom
+    def self.build_json_from_packet(packet, include_limits_states: true)
+      packet.decom(include_limits_states: include_limits_states)
     end
 
     # Get a Store instance routed to the correct db_shard for a target

data/lib/openc3/models/db_sharded_model.rb

@@ -79,7 +79,7 @@ module OpenC3
     end
 
     # DB_Shard-aware create: writes to the store instance for the given db_shard.
-    def _db_sharded_create(db_shard, update: false, force: false, queued: false, isoformat: false, expire_seconds: nil)
+    def _db_sharded_create(db_shard, update: false, force: false, queued: false, expire_seconds: nil)
       db_shard_store = self.class.store.instance(db_shard: db_shard)
       unless force
         existing = db_shard_store.hget(@primary_key, @name)
@@ -89,7 +89,7 @@ module OpenC3
           raise RuntimeError.new("#{@primary_key}:#{@name} doesn't exist at update") if update
         end
       end
-      @updated_at = isoformat ? Time.now.utc.iso8601 : Time.now.utc.to_nsec_from_epoch
+      @updated_at = Time.now.utc.to_nsec_from_epoch
 
       if queued
         store = self.class.store_queued.instance(db_shard: db_shard)

data/lib/openc3/models/interface_model.rb

@@ -444,9 +444,11 @@ module OpenC3
       microservice
     end
 
-    # Looks up the deployed MicroserviceModel and destroy the microservice model
-    # should should trigger the operator to kill the microservice that in turn
-    # will destroy the InterfaceStatusModel when a stop is called.
+    # Destroys the deployed MicroserviceModel which triggers the operator to kill
+    # the microservice. Also directly destroys the Interface/RouterStatusModel in
+    # an ensure block. The microservice stop() no longer recreates the status
+    # model once cancel_thread is set, so undeploy must clean it up itself to
+    # avoid leaving an orphaned status model behind.
     def undeploy
       type = self.class._get_type
       name = "#{@scope}__#{type}__#{@name}"
@@ -455,15 +457,19 @@ module OpenC3
         model.destroy
         ConfigTopic.write({ kind: 'deleted', type: type.downcase, name: @name, plugin: @plugin }, scope: @scope)
       end
-
-      if type == 'INTERFACE'
-        status_model = InterfaceStatusModel.get_model(name: @name, scope: @scope)
-      else
-        status_model = RouterStatusModel.get_model(name: @name, scope: @scope)
-      end
-      status_model.destroy if status_model
     rescue Exception => error
       Logger.error("Error undeploying interface/router model #{@name} in scope #{@scope} due to #{error}")
+    ensure
+      begin
+        if type == 'INTERFACE'
+          status_model = InterfaceStatusModel.get_model(name: @name, scope: @scope)
+        else
+          status_model = RouterStatusModel.get_model(name: @name, scope: @scope)
+        end
+        status_model.destroy if status_model
+      rescue Exception => error
+        Logger.error("Error destroying #{type&.downcase || 'unknown'} status model #{@name} in scope #{@scope} due to #{error}")
+      end
     end
 
     def unmap_target(target_name, cmd_only: false, tlm_only: false)

data/lib/openc3/models/interface_status_model.rb

@@ -118,8 +118,8 @@ module OpenC3
       @rxcnt = rxcnt
     end
 
-    def create(update: false, force: false, queued: false, isoformat: false)
-      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued, isoformat: isoformat)
+    def create(update: false, force: false, queued: false)
+      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued)
     end
 
     def destroy

data/lib/openc3/models/metric_model.rb

@@ -77,8 +77,8 @@ module OpenC3
       @db_shard = db_shard.to_i
     end
 
-    def create(update: false, force: false, queued: false, isoformat: false, expire_seconds: nil)
-      _db_sharded_create(@db_shard, update: update, force: force, queued: queued, isoformat: isoformat, expire_seconds: expire_seconds)
+    def create(update: false, force: false, queued: false, expire_seconds: nil)
+      _db_sharded_create(@db_shard, update: update, force: force, queued: queued, expire_seconds: expire_seconds)
     end
 
     def destroy

data/lib/openc3/models/microservice_status_model.rb

@@ -76,8 +76,8 @@ module OpenC3
       @custom = custom
     end
 
-    def create(update: false, force: false, queued: false, isoformat: false)
-      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued, isoformat: isoformat)
+    def create(update: false, force: false, queued: false)
+      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued)
     end
 
     def destroy