openc3 7.2.1 → 7.4.0

data/lib/openc3/interfaces/protocols/preidentified_protocol.rb

@@ -106,6 +106,13 @@ module OpenC3
       when 4
         string_length = string_length.unpack('N')[0] # UINT32
         raise "Length value received larger than max_length: #{string_length} > #{@max_length}" if @max_length and string_length > @max_length
+
+        # Reject up front rather than buffering the declared number of bytes first
+        if string_length > @max_buffer_size
+          reset() # Drop the partial frame rather than holding it until disconnect
+          raise "Length value received of #{string_length} bytes exceeds maximum buffer size of #{@max_buffer_size} bytes. " \
+                "Increase OPENC3_PROTOCOL_MAX_BUFFER_SIZE."
+        end
       else
         raise "Unsupported length given to read_length_field_followed_by_string: #{length_num_bytes}"
       end

data/lib/openc3/interfaces/protocols/protocol.rb

@@ -131,13 +131,13 @@ module OpenC3
     def write_details
       result = {'name' => self.class.name.to_s.split("::")[-1]}
       if @write_data_input_time
-        result['write_data_input_time'] = @write_data_input_time.iso8601
+        result['write_data_input_time'] = @write_data_input_time.getutc.iso8601(6)
       else
         result['write_data_input_time'] = nil
       end
       result['write_data_input'] = @write_data_input
       if @write_data_output_time
-        result['write_data_output_time'] = @write_data_output_time.iso8601
+        result['write_data_output_time'] = @write_data_output_time.getutc.iso8601(6)
       else
         result['write_data_output_time'] = nil
       end
@@ -148,13 +148,13 @@ module OpenC3
     def read_details
       result = {'name' => self.class.name.to_s.split("::")[-1]}
       if @read_data_input_time
-        result['read_data_input_time'] = @read_data_input_time.iso8601
+        result['read_data_input_time'] = @read_data_input_time.getutc.iso8601(6)
       else
         result['read_data_input_time'] = nil
       end
       result['read_data_input'] = @read_data_input
       if @read_data_output_time
-        result['read_data_output_time'] = @read_data_output_time.iso8601
+        result['read_data_output_time'] = @read_data_output_time.getutc.iso8601(6)
       else
         result['read_data_output_time'] = nil
       end

data/lib/openc3/interfaces/protocols/template_protocol.rb

@@ -266,7 +266,7 @@ module OpenC3
       result['response_timeout'] = @response_timeout
       result['response_polling_period'] = @response_polling_period
       if @connect_complete_time
-        result['connect_complete_time'] = @connect_complete_time.iso8601
+        result['connect_complete_time'] = @connect_complete_time.getutc.iso8601(6)
       else
         result['connect_complete_time'] = nil
       end
@@ -285,7 +285,7 @@ module OpenC3
       result['response_timeout'] = @response_timeout
       result['response_polling_period'] = @response_polling_period
       if @connect_complete_time
-        result['connect_complete_time'] = @connect_complete_time.iso8601
+        result['connect_complete_time'] = @connect_complete_time.getutc.iso8601(6)
       else
         result['connect_complete_time'] = nil
       end

data/lib/openc3/interfaces/serial_interface.rb

@@ -77,6 +77,8 @@ module OpenC3
 
     # Creates a new {SerialStream} using the parameters passed in the constructor
     def connect
+      # Cleanly close any existing stream rather than leaving it open
+      @stream.disconnect if @stream
       @stream = SerialStream.new(
         @write_port_name,
         @read_port_name,

data/lib/openc3/interfaces/tcpip_client_interface.rb

@@ -76,6 +76,8 @@ module OpenC3
     # Connects the {TcpipClientStream} by passing the
     # initialization parameters to the {TcpipClientStream}.
     def connect
+      # Cleanly close any existing stream rather than leaving it open
+      @stream.disconnect if @stream
       @stream = TcpipClientStream.new(
         @hostname,
         @write_port,

data/lib/openc3/interfaces/udp_interface.rb

@@ -23,6 +23,7 @@ module OpenC3
   # Base class for interfaces that send and receive messages over UDP
   class UdpInterface < Interface
     HOST_127_0_0_1 = '127.0.0.1'
+    HOST_0_0_0_0 = '0.0.0.0'
 
     # @param hostname [String] Machine to connect to
     # @param write_dest_port [Integer] Port to write commands to
@@ -77,8 +78,11 @@ module OpenC3
       @read_timeout = ConfigParser.handle_nil(read_timeout)
       @read_timeout = @read_timeout.to_f if @read_timeout
       @bind_address = ConfigParser.handle_nil(bind_address)
-      if @bind_address && @bind_address.casecmp('LOCALHOST').zero?
-        @bind_address = HOST_127_0_0_1
+      if @bind_address
+        @bind_address = HOST_127_0_0_1 if @bind_address.casecmp('LOCALHOST').zero?
+      else
+        # nil means all local addresses which is what 0.0.0.0 means
+        @bind_address = HOST_0_0_0_0
       end
       @write_socket = nil
       @read_socket = nil
@@ -91,9 +95,9 @@ module OpenC3
       result = ''
       result += " #{@hostname}:#{@write_dest_port} (write dest port)" if @write_dest_port
       result += " #{@write_src_port} (write src port)" if @write_src_port
-      result += " #{@hostname}:#{@read_port} (read)" if @read_port
+      result += " #{@bind_address}:#{@read_port} (read)" if @read_port
       result += " #{@interface_address} (interface addr)" if @interface_address
-      result += " #{@bind_address} (bind addr)" if @bind_address != '0.0.0.0'
+      result += " #{@bind_address} (bind addr)" if @bind_address != HOST_0_0_0_0
       return result.strip
     end
 
@@ -102,13 +106,20 @@ module OpenC3
     # the constructor.
     def connect
       if @read_port and @write_dest_port and @write_src_port and (@read_port == @write_src_port)
+        # read_multicast is false because this socket is not connected and thus
+        # doesn't filter by peer address. Joining the multicast group we write to
+        # would deliver our own commands back to us as telemetry (multicast
+        # loopback is enabled by default).
         @read_socket = UdpReadWriteSocket.new(
           @read_port,
           @bind_address,
           @write_dest_port,
           @hostname,
           @interface_address,
-          @ttl
+          @ttl,
+          false, # read_multicast
+          true,  # write_multicast
+          false  # connect_socket
         )
         @write_socket = @read_socket
       else

data/lib/openc3/io/json_api.rb

@@ -35,8 +35,9 @@ module OpenC3
     # pull openc3-cosmos-script-runner-api url from environment variables
     def _generate_url(microservice_name:, prefix:, schema: 'http', hostname: nil, port:, scope: $openc3_scope)
       prefix = '/' + prefix unless prefix[0] == '/'
-      if ENV['OPENC3_OPERATOR_HOSTNAME']
-        hostname = ENV['OPENC3_OPERATOR_HOSTNAME'] unless hostname
+      operator_hostname = ENV.fetch('OPENC3_OPERATOR_HOSTNAME', nil)
+      if operator_hostname
+        hostname = operator_hostname unless hostname
         return "#{schema}://#{hostname}:#{port.to_i}#{prefix}"
       else
         if ENV['KUBERNETES_SERVICE_HOST']

data/lib/openc3/io/json_drb.rb

@@ -17,6 +17,7 @@
 
 require 'socket'
 require 'json'
+require 'set'
 # require 'drb/acl'
 require 'drb/drb'
 require 'openc3/io/json_rpc'
@@ -47,8 +48,9 @@ module OpenC3
   # JsonDRb implements the JSON-RPC 2.0 Specification to provide an interface
   # for both internal and external tools to access the OpenC3 server. It
   # provides methods to install an access control list to control access to the
-  # API. It also limits the available methods to a known list of allowable API
-  # methods.
+  # API. Access is controlled by a required method_whitelist which names every
+  # method that may be invoked. There is no permissive fallback: any method not
+  # explicitly listed is rejected.
   class JsonDRb
     # Minimum amount of time in seconds to receive the JSON request,
     # process it, and send the response. Requests for less than this amount
@@ -62,18 +64,21 @@ module OpenC3
 
     # @return [Integer] The number of JSON-RPC requests processed
     attr_accessor :request_count
-    # @return [Array<String>] List of methods that should be allowed
-    attr_accessor :method_whitelist
+    # @return [Set<String>] Set of downcased method names which may be called
+    attr_reader :method_whitelist
     # @return [ACL] The access control list
     # attr_accessor :acl
 
     attr_accessor :object
 
-    def initialize
+    # @param method_whitelist [Enumerable<String>] Every method name which may
+    #   be called over JSON-RPC. Required and must not be empty since there is
+    #   no permissive fallback.
+    def initialize(method_whitelist:)
+      self.method_whitelist = method_whitelist
       @thread = nil
       # @acl = nil
       @object = nil
-      @method_whitelist = nil
       @request_count = 0
       @request_times = []
       @request_times_index = 0
@@ -82,6 +87,18 @@ module OpenC3
       @server_mutex = Mutex.new
     end
 
+    # Replaces the set of methods which may be called over JSON-RPC. Names are
+    # downcased to match the dispatch in {#process_request}.
+    #
+    # @param whitelist [Enumerable<String>] Every method name which may be called
+    def method_whitelist=(whitelist)
+      if whitelist.nil? or whitelist.to_a.empty?
+        raise ArgumentError, "method_whitelist is required and must not be empty"
+      end
+
+      @method_whitelist = whitelist.map { |name| name.to_s.downcase }.to_set
+    end
+
     # Returns the number of connected clients
     # @return [Integer] The number of connected clients
     def num_clients
@@ -254,8 +271,7 @@ module OpenC3
         error_code = nil
         response_data = nil
 
-        if (@method_whitelist and @method_whitelist.include?(request.method.downcase())) or
-           (!@method_whitelist and !JsonRpcRequest::DANGEROUS_METHODS.include?(request.method.downcase()))
+        if @method_whitelist.include?(request.method.downcase())
           begin
             if request.keyword_params
               result = @object.public_send(request.method.downcase().intern, *request.params, **request.keyword_params)
@@ -266,10 +282,26 @@ module OpenC3
               response = JsonRpcSuccessResponse.new(result, request.id)
             end
           rescue Exception => e
-            # Filter out the framework stack trace (rails, rack, puma etc)
-            lines = e.formatted.split("\n")
-            i = lines.find_index { |row| row.include?('actionpack') || row.include?('activesupport') }
-            Logger.error lines[0...i].join("\n")
+            error_name = e.class.name.split('::')[-1]
+            method_name = request.method.downcase()
+            case e
+            when AuthError, ForbiddenError
+              # Auth failures are expected (e.g. browser requests before login or with an
+              # expired session token) so log a single line without the stack trace
+              Logger.warn "#{error_name} : #{e.message} calling #{method_name}"
+            when HazardousError, CriticalCmdError
+              # Not errors at all: these are the signal that the UI should raise an
+              # operator confirmation dialog, and the user retries with the hazardous
+              # or critical flag set. A stack trace per prompt is pure noise, and
+              # HazardousError#to_s embeds the formatted command with a newline,
+              # so log just the error name and the method that raised it.
+              Logger.info "#{error_name} calling #{method_name}"
+            else
+              # Filter out the framework stack trace (rails, rack, puma etc)
+              lines = e.formatted.split("\n")
+              i = lines.find_index { |row| row.include?('actionpack') || row.include?('activesupport') }
+              Logger.error lines[0...(i || lines.length)].join("\n")
+            end
 
             if request.id
               if NoMethodError === e

data/lib/openc3/io/json_rpc.rb

@@ -227,8 +227,6 @@ module OpenC3
 
   # Represents a JSON Remote Procedure Call Request
   class JsonRpcRequest < JsonRpc
-    DANGEROUS_METHODS = Set['__send__', 'send', 'instance_eval', 'instance_exec']
-
     # @param method_name [String] The name of the method to call
     # @param method_params [Array<String>] Array of strings which represent the
     #   parameters to send to the method

data/lib/openc3/io/udp_sockets.rb

@@ -27,6 +27,9 @@ module OpenC3
   class UdpReadWriteSocket
     HOST_0_0_0_0 = '0.0.0.0'
 
+    # MSG_DONTWAIT is not defined on Windows where sends are left blocking
+    WRITE_FLAGS = Socket.const_defined?('MSG_DONTWAIT') ? Socket::MSG_DONTWAIT : 0
+
     # @param bind_port [Integer[ Port to write data out from and receive data on (0 = randomly assigned)
     # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
     # @param external_port [Integer] External port to write to
@@ -35,6 +38,8 @@ module OpenC3
     # @param ttl [Integer] Time To Live for outgoing multicast packets
     # @param read_multicast [Boolean] Whether or not to try to read from the external address as multicast
     # @param write_multicast [Boolean] Whether or not to write to the external address as multicast
+    # @param connect_socket [Boolean] Whether to connect the socket to the external address. If false,
+    #   writes explicitly address each datagram so reads can accept datagrams from any source.
     def initialize(
       bind_port = 0,
       bind_address = HOST_0_0_0_0,
@@ -43,10 +48,23 @@ module OpenC3
       multicast_interface_address = nil,
       ttl = 1,
       read_multicast = true,
-      write_multicast = true
+      write_multicast = true,
+      connect_socket = true
     )
 
       @socket = UDPSocket.new
+      @external_address = external_address
+      @external_port = external_port
+      @connect_socket = connect_socket
+      # Resolve the destination once at creation time so writes don't pay for a
+      # (potentially blocking) name lookup on every datagram
+      @external_sockaddr = nil
+      if !connect_socket and external_address and external_port
+        # Explicitly resolve IPv4 because UDPSocket is an AF_INET socket and
+        # sockaddr_in would otherwise hand back an IPv6 address for names like localhost
+        ip_address = Socket.getaddrinfo(external_address, nil, Socket::AF_INET, Socket::SOCK_DGRAM)[0][3]
+        @external_sockaddr = Socket.sockaddr_in(external_port, ip_address)
+      end
 
       # Basic setup to reuse address
       @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
@@ -55,10 +73,10 @@ module OpenC3
       @socket.bind(bind_address, bind_port) if bind_address and bind_port
 
       # Default send to the specified address and port
-      @socket.connect(external_address, external_port) if external_address and external_port
+      @socket.connect(external_address, external_port) if connect_socket and external_address and external_port
 
       # Handle multicast
-      if UdpReadWriteSocket.multicast?(external_address, external_port)
+      if UdpReadWriteSocket.multicast?(external_address)
         if write_multicast
           # Basic setup set time to live
           @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, ttl.to_i)
@@ -90,7 +108,13 @@ module OpenC3
 
       loop do
         begin
-          bytes_sent = @socket.write_nonblock(data_to_send)
+          if @external_sockaddr
+            # send is used rather than sendmsg_nonblock because sendmsg is not
+            # implemented on Windows
+            bytes_sent = @socket.send(data_to_send, WRITE_FLAGS, @external_sockaddr)
+          else
+            bytes_sent = @socket.write_nonblock(data_to_send)
+          end
         rescue Errno::EAGAIN, Errno::EWOULDBLOCK
           result = IO.fast_select(nil, [@socket], nil, write_timeout)
           if result
@@ -129,12 +153,18 @@ module OpenC3
     end
 
     # @param host [String] Machine name or IP address
-    # @param port [String] Port
+    # @param port [String] Port (unused, kept for backwards compatibility)
     # @return [Boolean] Whether the hostname is multicast
-    def self.multicast?(host, port)
-      return false if host.nil? || port.nil?
+    def self.multicast?(host, port = nil)
+      return false if host.nil?
 
-      Addrinfo.udp(host, port).ipv4_multicast?
+      begin
+        Addrinfo.udp(host, 0).ipv4_multicast?
+      rescue SocketError, ArgumentError
+        # Hostname isn't resolvable so it can't be a multicast address we handle.
+        # Reads don't need the hostname at all so don't fail creating the socket.
+        false
+      end
     end
   end
 

data/lib/openc3/io/win32_serial_driver.rb

@@ -16,6 +16,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/win32/win32'
+require 'openc3/io/serial_driver'
 require 'timeout' # For Timeout::Error
 
 module OpenC3

data/lib/openc3/logs/log_writer.rb

@@ -113,6 +113,7 @@ module OpenC3
       @cycle_minute = Integer(@cycle_minute) if @cycle_minute
       @enforce_time_order = ConfigParser.handle_true_false(enforce_time_order)
       @out_of_order = false
+      @bad_time = false
       @mutex = Mutex.new
       @file = nil
       @file_size = 0
@@ -125,6 +126,13 @@ module OpenC3
       @cleanup_offsets = []
       @cleanup_times = []
       @previous_time_nsec_since_epoch = nil
+      # Stored packets older than 20 years are treated as invalid (e.g. 1970 before
+      # clock/GPS sync). They never drive file segmentation nor become the ordering
+      # baseline, so a late-syncing clock doesn't thrash log files.
+      @min_valid_time_nsec = (@start_time - (20 * 365 * 24 * 60 * 60)).to_nsec_from_epoch
+      # Validity (valid/invalid time) of the packets in the currently open file. Used to
+      # segregate invalid-time (1970) packets into their own file. nil = no packets yet.
+      @current_file_valid = nil
       @tmp_dir = Dir.mktmpdir
       @wait_threads = []
 
@@ -280,6 +288,7 @@ module OpenC3
       @first_time = nil
       @last_time = nil
       @previous_time_nsec_since_epoch = nil
+      @current_file_valid = nil
       Logger.debug "Log File Opened : #{@filename}"
     rescue => e
       Logger.error "Error starting new log file: #{e.formatted}"
@@ -289,7 +298,14 @@ module OpenC3
 
     # @enforce_time_order requires the timestamps on each write to be greater than the previous
     # process_out_of_order ignores the timestamps for the current entry (used to ignore timestamps on metadata entries, vs actual packets)
-    def prepare_write(time_nsec_since_epoch, data_length, redis_topic = nil, redis_offset = nil, allow_new_file: true, process_out_of_order: true)
+    # stored: stored packets roll a new file when GOOD times move backward (a new /
+    #   overlapping replay run). Packets with an invalid time (e.g. 1970 before clock/GPS
+    #   sync) - realtime or stored - are segregated into their own file: the first valid
+    #   packet after a run of 1970s rolls a fresh, properly-named file (and vice-versa).
+    def prepare_write(time_nsec_since_epoch, data_length, redis_topic = nil, redis_offset = nil, allow_new_file: true, process_out_of_order: true, stored: false)
+      # An invalid time is a packet from before the clock/GPS synced (e.g. 1970). This
+      # applies to both realtime and stored packets so neither taints a file's filename.
+      packet_valid = !(process_out_of_order and time_nsec_since_epoch < @min_valid_time_nsec)
       # This check includes logging_enabled again because it might have changed since we acquired the mutex
       # Ensures new files based on size, and ensures always increasing time order in files
       if @logging_enabled
@@ -299,17 +315,37 @@ module OpenC3
         elsif @cycle_size and ((@file_size + data_length) > @cycle_size)
           Logger.debug("Log writer start new file due to cycle size #{@cycle_size}")
           start_new_file() if allow_new_file
+        elsif process_out_of_order and !@current_file_valid.nil? and packet_valid != @current_file_valid and allow_new_file
+          # Time validity changed (1970 <-> valid): segregate invalid-time packets into
+          # their own file so valid files keep a clean, correctly-timed filename.
+          Logger.debug("Log writer start new file due to time validity change")
+          start_new_file()
         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)
-          # Warning: Creating new files here can cause lots of files to be created if packets make it through out of order
-          # Changed to just a error to prevent file thrashing
-          unless @out_of_order
-            Logger.error("Log writer out of order time detected (increase buffer depth?): #{Time.from_nsec_from_epoch(@previous_time_nsec_since_epoch)} #{Time.from_nsec_from_epoch(time_nsec_since_epoch)}")
-            @out_of_order = true
+          if stored and packet_valid and allow_new_file
+            # Good stored time went backward => new/overlapping replay run. Roll a new
+            # file so each stored file stays monotonic (start_new_file resets @previous_time).
+            Logger.debug("Log writer start new file due to out of order stored time")
+            start_new_file()
+          elsif !stored
+            # Warning: Creating new files here can cause lots of files to be created if packets make it through out of order
+            # Changed to just a warning to prevent file thrashing
+            unless @out_of_order
+              Logger.warn("Log writer out of order time detected (increase buffer depth?): #{Time.from_nsec_from_epoch(@previous_time_nsec_since_epoch)} #{Time.from_nsec_from_epoch(time_nsec_since_epoch)}")
+              @out_of_order = true
+            end
           end
         end
       end
       @last_offsets[redis_topic] = redis_offset if redis_topic and redis_offset # This is needed for the redis offset marker entry at the end of the log file
-      @previous_time_nsec_since_epoch = time_nsec_since_epoch if process_out_of_order
+      if process_out_of_order
+        @current_file_valid = packet_valid
+        if packet_valid
+          @previous_time_nsec_since_epoch = time_nsec_since_epoch
+        elsif !@bad_time
+          Logger.warn("Log writer segregating invalid packet time (before clock sync?): #{Time.from_nsec_from_epoch(time_nsec_since_epoch)}")
+          @bad_time = true
+        end
+      end
     end
 
     # Closing a log file isn't critical so we just log an error. NOTE: This also trims the Redis stream

data/lib/openc3/logs/packet_log_reader.rb

@@ -142,7 +142,7 @@ module OpenC3
         end
       elsif flags & OPENC3_ENTRY_TYPE_MASK == OPENC3_RAW_PACKET_ENTRY_TYPE_MASK
         packet_index, time_nsec_since_epoch = entry[2..11].unpack('nQ>')
-        received_time_nsec_since_epoch, _extra, packet_data = handle_received_time_extra_and_data(entry, time_nsec_since_epoch, includes_received_time, includes_extra, cbor)
+        received_time_nsec_since_epoch, extra, packet_data = handle_received_time_extra_and_data(entry, time_nsec_since_epoch, includes_received_time, includes_extra, cbor)
         lookup_cmd_or_tlm, target_name, packet_name, _id = @packets[packet_index]
         if cmd_or_tlm != lookup_cmd_or_tlm
           raise "Packet type mismatch, packet:#{cmd_or_tlm}, lookup:#{lookup_cmd_or_tlm}"
@@ -159,6 +159,10 @@ module OpenC3
         packet.set_received_time_fast(received_time)
         packet.cmd_or_tlm = cmd_or_tlm
         packet.stored = stored
+        # Assigned unconditionally because identify_and_define_packet_data
+        # returns the shared System packet, so a nil extra here must clear
+        # the extra left over from a previous read of the same packet
+        packet.extra = extra
         packet.received_count += 1
         return packet
       elsif flags & OPENC3_ENTRY_TYPE_MASK == OPENC3_TARGET_DECLARATION_ENTRY_TYPE_MASK
@@ -304,7 +308,24 @@ module OpenC3
         if cbor
           extra = CBOR.decode(extra_encoded)
         else
-          extra = JSON.parse(extra_encoded, allow_nan: true, create_additions: true)
+          begin
+            extra = JSON.parse(extra_encoded, allow_nan: true, create_additions: true)
+          rescue JSON::ParserError => e
+            # PacketLogWriter up to version 7.3.0 CBOR encoded the extra on
+            # RAW_PACKET entries without setting OPENC3_CBOR_FLAG_MASK, so the
+            # flag claims JSON while the bytes are CBOR. Retry as CBOR so those
+            # existing files can still be read. extra is always a Hash, so a
+            # decode to anything else means these bytes aren't the legacy
+            # encoding either and the original JSON error is the useful one.
+            decoded = begin
+              CBOR.decode(extra_encoded)
+            rescue StandardError
+              raise e
+            end
+            raise e unless Hash === decoded
+
+            extra = decoded
+          end
         end
       end
       data = entry[next_offset..-1]

data/lib/openc3/logs/packet_log_writer.rb

@@ -96,13 +96,12 @@ module OpenC3
       @mutex.lock if take_mutex
       begin
         if entry_type == :RAW_PACKET or entry_type == :JSON_PACKET
-          # Only care about the timestamps on the real packets being in order
           process_out_of_order = true
         else
           # Metadata timestamps don't matter
           process_out_of_order = false
         end
-        prepare_write(time_nsec_since_epoch, data.length, redis_topic, redis_offset, allow_new_file: allow_new_file, process_out_of_order: process_out_of_order)
+        prepare_write(time_nsec_since_epoch, data.length, redis_topic, redis_offset, allow_new_file: allow_new_file, process_out_of_order: process_out_of_order, stored: stored)
         write_entry(entry_type, cmd_or_tlm, target_name, packet_name, time_nsec_since_epoch, stored, data, id, received_time_nsec_since_epoch: received_time_nsec_since_epoch, extra: extra) if @file
       ensure
         @mutex.unlock if take_mutex
@@ -312,6 +311,11 @@ module OpenC3
           extra = JSON.parse(extra, allow_nan: true, create_additions: true) if String === extra
           length += OPENC3_EXTRA_LENGTH_FIXED_SIZE
           if @data_format == :CBOR
+            # The reader uses this same flag to pick the extra decoder, so it
+            # must be set here as well as in the JSON_PACKET data branch above.
+            # RAW_PACKET entries never reach that branch and would otherwise
+            # write CBOR extra that the reader tries to JSON.parse.
+            flags |= OPENC3_CBOR_FLAG_MASK
             extra_encoded = extra.as_json.to_cbor
           else
             extra_encoded = JSON.generate(extra.as_json, allow_nan: true)

data/lib/openc3/logs/stream_log.rb

@@ -47,7 +47,7 @@ module OpenC3
       raise "log_type must be :READ or :WRITE" unless LOG_TYPES.include? log_type
 
       super(
-        "#{ENV['OPENC3_SCOPE']}/stream_logs/",
+        "#{ENV.fetch('OPENC3_SCOPE', 'DEFAULT')}/stream_logs/",
         true, # Start with logging enabled
         cycle_time,
         cycle_size,

data/lib/openc3/microservices/interface_decom_common.rb

@@ -33,7 +33,8 @@ module OpenC3
       end
       stored = inject_tlm_hash.fetch('stored', false)
       packet.stored = stored.to_s.downcase == 'true'
-      packet.received_time = Time.now.sys
+      received_time = inject_tlm_hash['received_time']
+      packet.received_time = received_time.nil? ? Time.now.sys : Time.from_nsec_from_epoch(received_time).sys
       packet.received_count = TargetModel.increment_telemetry_count(packet.target_name, packet.packet_name, 1, scope: @scope)
       TelemetryTopic.write_packet(packet, scope: @scope)
     end