stored=True packets should bypass log writer time order enforcement

[marty-brandt-ctr]

Describe the bug

When injecting historical telemetry with packet.stored = True and a past received_time, the log writer still compares the packet's timestamp against previous_time_nsec_since_epoch and logs an error:

Log writer out of order time detected (increase buffer depth?): 1970-01-01 00:46:34

Actual behavior: The stored flag is written as a bitmask to the log file but is never checked in the time order enforcement logic in log_writer.py. This means any live telemetry packet received between two historical injections will trigger the error.

Suggested fix: In prepare_write inside log_writer.py, skip the time order check when the packet has stored=True:

if not packet.stored and self.enforce_time_order and ...:
Logger.error("Log writer out of order time detected ...")

To Reproduce

Inject historical telemetry with stored=true with a received_time in the past and then inject one with stored=false with a modern received_time and see the error.

Expected behavior

Packets with stored=True are intentionally historical and should bypass the enforce_time_order check entirely, since interleaving live and stored packets will always produce out-of-order timestamps by design.

Screenshots

No response

OS

windows 10

OpenC3 COSMOS Version

7.1.0

Browser

Chrome

[crawlchat]

Thanks for the detailed bug report! This is a well-observed issue. Let me confirm the findings by checking the actual code.

📋 Analysis

You've correctly identified the behavior. Here's what the code currently does:

Ruby (log_writer.rb line 302):

elsif process_out_of_order and @enforce_time_order and @previous_time_nsec_since_epoch and (@previous_time_nsec_since_epoch > time_nsec_since_epoch)
  Logger.error("Log writer out of order time detected ...")

Python (log_writer.py line 280-284):

elif (
    self.enforce_time_order
    and self.previous_time_nsec_since_epoch
    and (self.previous_time_nsec_since_epoch > time_nsec_since_epoch)
):
    Logger.error("Log writer out of order time detected ...")

The stored flag is passed all the way through to write_entry (where it's written as a bitmask), but it is never checked in prepare_write's time order enforcement logic. Your analysis is correct.

✅ Suggested Fix

The Ruby fix in packet_log_writer.rb would mirror what's already done for metadata packets — set process_out_of_order = false when stored == true:

if entry_type == :RAW_PACKET or entry_type == :JSON_PACKET
  # Skip time order check for stored (historical) packets
  process_out_of_order = !stored
else
  process_out_of_order = false
end

And similarly in Python's packet_log_writer.py, the stored parameter should be passed through and used to skip the check in prepare_write.

This looks like a genuine bug. The stored flag is already well-supported throughout the log writing pipeline — it's just not being respected in the time-order enforcement path. Your suggested fix is sound and aligns with the existing pattern used for metadata entries (process_out_of_order = false).

Could you open a proper GitHub issue (if this isn't already one) or submit a PR against the OpenC3/cosmos repo? The fix would need to be applied in both the Ruby and Python implementations. The OpenC3 team would be the best people to review and merge this. 🙏