openc3 7.0.0.pre.rc3 → 7.0.1

data/lib/openc3/microservices/interface_microservice.rb

@@ -179,7 +179,12 @@ module OpenC3
               next 'SUCCESS'
             end
             if msg_hash.key?('inject_tlm')
-              handle_inject_tlm(msg_hash['inject_tlm'])
+              begin
+                handle_inject_tlm(msg_hash['inject_tlm'])
+              rescue => e
+                @logger.error "#{@interface.name}: inject_tlm: #{e.formatted}"
+                next e.message
+              end
               next 'SUCCESS'
             end
             if msg_hash.key?('release_critical')
@@ -779,7 +784,6 @@ module OpenC3
         else
           @logger.error "#{@interface.name}: #{connect_error.formatted}"
           unless @connection_failed_messages.include?(connect_error.message)
-            OpenC3.write_exception_file(connect_error)
             @connection_failed_messages << connect_error.message
           end
         end
@@ -800,7 +804,6 @@ module OpenC3
         else
           @logger.error "#{@interface.name}: #{err.formatted}"
           unless @connection_lost_messages.include?(err.message)
-            OpenC3.write_exception_file(err)
             @connection_lost_messages << err.message
           end
         end
@@ -888,6 +891,14 @@ module OpenC3
     def shutdown(_sig = nil)
       @logger.info "#{@interface ? @interface.name : @name}: shutdown requested"
       stop()
+      if @interface and @interface.stream_log_pair
+        threads = @interface.stream_log_pair.shutdown
+        # Wait for all the logging threads to move files to buckets
+        threads.flatten.compact.each do |thread|
+          thread.join
+        end
+        @interface.stream_log_pair.cleanup
+      end
       super()
     end
 

data/lib/openc3/microservices/log_microservice.rb

@@ -125,8 +125,8 @@ module OpenC3
     def shutdown
       # Make sure all the existing logs are properly closed down
       threads = []
-      @plws.each do |target_name, plw_hash|
-        plw_hash.each do |type, plw|
+      @plws.each do |_target_name, plw_hash|
+        plw_hash.each do |_type, plw|
           threads.concat(plw.shutdown)
         end
       end
@@ -134,6 +134,11 @@ module OpenC3
       threads.flatten.compact.each do |thread|
         thread.join
       end
+      @plws.each do |_target_name, plw_hash|
+        plw_hash.each do |_type, plw|
+          plw.cleanup
+        end
+      end
       super()
     end
   end

data/lib/openc3/microservices/microservice.rb

@@ -88,6 +88,7 @@ module OpenC3
       @name = name
       split_name = name.split("__")
       raise "Name #{name} doesn't match convention of SCOPE__TYPE__NAME" if split_name.length != 3
+      microservice_type = split_name[1].to_s.upcase
 
       @scope = split_name[0]
       $openc3_scope = @scope
@@ -102,8 +103,14 @@ module OpenC3
 
       OpenC3.setup_open_telemetry(@name, false)
 
+      @temp_dir = OpenC3.sanitize_path(File.join(Dir.tmpdir, @name))
+
       # Create temp folder for this microservice
-      @temp_dir = Dir.mktmpdir
+      # This will already have been setup by plugin_microservice.rb if USER
+      if is_plugin or microservice_type != 'USER'
+        FileUtils.remove_entry_secure(@temp_dir, true)
+        Dir.mkdir(@temp_dir)
+      end
 
       # Get microservice configuration from Redis
       @config = MicroserviceModel.get(name: @name, scope: @scope)
@@ -142,14 +149,13 @@ module OpenC3
         cmd_array = @config["cmd"]
 
         # Get Microservice files from bucket storage
-        temp_dir = Dir.mktmpdir
         bucket = ENV['OPENC3_CONFIG_BUCKET']
         client = Bucket.getClient()
 
         prefix = "#{@scope}/microservices/#{@name}/"
         file_count = 0
         client.list_objects(bucket: bucket, prefix: prefix).each do |object|
-          response_target = File.join(temp_dir, object.key.split(prefix)[-1])
+          response_target = OpenC3.sanitize_path(File.join(@temp_dir, object.key.split(prefix)[-1]))
           FileUtils.mkdir_p(File.dirname(response_target))
           client.get_object(bucket: bucket, key: object.key, path: response_target)
           file_count += 1
@@ -157,7 +163,7 @@ module OpenC3
 
         # Adjust @work_dir to microservice files downloaded if files and a relative path
         if file_count > 0 and @work_dir[0] != '/'
-          @work_dir = File.join(temp_dir, @work_dir)
+          @work_dir = OpenC3.sanitize_path(File.join(@temp_dir, @work_dir))
         end
 
         # Check Syntax on any ruby files

data/lib/openc3/microservices/queue_microservice.rb

@@ -18,6 +18,8 @@ require 'openc3/utilities/authentication'
 require 'openc3/api/api'
 
 module OpenC3
+  saved_verbose = $VERBOSE
+  $VERBOSE = false
   module Script
     private
     # Override the prompt_for_hazardous method to always return true since there is no user to prompt
@@ -25,6 +27,7 @@ module OpenC3
       return true
     end
   end
+  $VERBOSE = saved_verbose
 
   # The queue processor runs in a single thread and processes commands via cmd_api.
   class QueueProcessor

data/lib/openc3/microservices/scope_cleanup_microservice.rb

@@ -16,6 +16,120 @@ require 'openc3/microservices/cleanup_microservice'
 
 module OpenC3
   class ScopeCleanupMicroservice < CleanupMicroservice
+    TSDB_HEALTH_QUERY =
+"SELECT
+    table_name,
+    table_row_count,
+    wal_pending_row_count,
+    CASE
+        WHEN table_suspended THEN 'SUSPENDED'
+        WHEN table_memory_pressure_level = 2 THEN 'BACKOFF'
+        WHEN table_memory_pressure_level = 1 THEN 'PRESSURE'
+        ELSE 'OK'
+    END AS status,
+    wal_txn - table_txn AS lag_txns,
+    table_write_amp_p50 AS write_amp,
+    table_merge_rate_p99 AS slowest_merge
+FROM tables()
+WHERE walEnabled
+ORDER BY
+    table_suspended DESC,
+    table_memory_pressure_level DESC,
+    wal_pending_row_count DESC;"
+
+    GROWTH_NUM_SAMPLE_PERIODS = 4
+
+    def initialize(*args)
+      super(*args)
+      @run_time = nil
+      @cleanup_poll_time = nil
+      @delta_time = 0.0
+      @wal_pending_row_count = {}
+      @lag_txns = {}
+    end
+
+    def cleanup(areas, bucket)
+      current_time = Time.now
+      if @run_time
+        delta = current_time - @run_time
+        if delta > 0.0
+          @delta_time += delta
+        end
+      end
+      @run_time = current_time
+      if @delta_time > @cleanup_poll_time
+        @delta_time = 0.0
+        super(areas, bucket)
+      end
+
+      # Always check TSDB health
+      if @scope == 'DEFAULT'
+        begin
+          conn = OpenC3::QuestDBClient.connection
+          result = conn.exec(TSDB_HEALTH_QUERY)
+          columns = result.fields
+          rows = result.values
+
+          table_name_column = columns.index("table_name")
+          wal_pending_row_count_column = columns.index("wal_pending_row_count")
+          status_column = columns.index("status")
+          lag_txns_column = columns.index("lag_txns")
+
+          rows.each do |values|
+            table_name = values[table_name_column]
+            wal_pending_row_count = values[wal_pending_row_count_column].to_i
+            status = values[status_column]
+            lag_txns = values[lag_txns_column].to_i
+
+            if status != 'OK'
+              @logger.error("QuestDB: #{table_name} in bad state: #{status}")
+
+              if status == 'SUSPENDED'
+                # Try to automatically unsuspend
+                @logger.info("QuestDB: Attempting to unsuspend: #{table_name}")
+                conn.exec("ALTER TABLE #{table_name} RESUME WAL;")
+              end
+            end
+
+            @wal_pending_row_count[table_name] ||= []
+            @wal_pending_row_count[table_name] << wal_pending_row_count
+            @lag_txns[table_name] ||= []
+            @lag_txns[table_name] << lag_txns
+
+            if @wal_pending_row_count[table_name].length > GROWTH_NUM_SAMPLE_PERIODS
+              if detect_growth(@wal_pending_row_count[table_name], GROWTH_NUM_SAMPLE_PERIODS)
+                # Crossed threshold of sample periods of growth
+                @logger.error("QuestDB: #{table_name} has growing wal_pending_row_count: #{wal_pending_row_count}")
+              end
+
+              # Leave the last GROWTH_NUM_SAMPLE_PERIODS samples
+              @wal_pending_row_count[table_name] = @wal_pending_row_count[table_name][-GROWTH_NUM_SAMPLE_PERIODS..-1]
+            end
+
+            if @lag_txns[table_name].length > GROWTH_NUM_SAMPLE_PERIODS
+              if detect_growth(@lag_txns[table_name], GROWTH_NUM_SAMPLE_PERIODS)
+                # Crossed threshold of sample periods of growth
+                @logger.error("QuestDB: #{table_name} has growing lag_txns: #{lag_txns}")
+              end
+
+              # Leave the last GROWTH_NUM_SAMPLE_PERIODS samples
+              @lag_txns[table_name] = @lag_txns[table_name][-GROWTH_NUM_SAMPLE_PERIODS..-1]
+            end
+          end
+        rescue => e
+          OpenC3::QuestDBClient.disconnect
+          @logger.error("QuestDB Error: #{e.formatted}")
+        end
+      end
+    end
+
+    def detect_growth(array, num_samples)
+      num_samples.times do |index|
+        return false if array[index + 1] <= array[index]
+      end
+      return true
+    end
+
     def get_areas_and_poll_time
       scope = ScopeModel.get_model(name: @scope)
       areas = [
@@ -28,7 +142,8 @@ module OpenC3
         areas << ["NOSCOPE/tool_logs/sr", scope.tool_log_retain_time]
       end
 
-      return areas, scope.cleanup_poll_time
+      @cleanup_poll_time = scope.cleanup_poll_time
+      return areas, 60 # Run every 1 minute for TSDB checks
     end
   end
 end

data/lib/openc3/microservices/text_log_microservice.rb

@@ -98,13 +98,16 @@ module OpenC3
     def shutdown
       # Make sure all the existing logs are properly closed down
       threads = []
-      @tlws.each do |topic, tlw|
+      @tlws.each do |_topic, tlw|
         threads.concat(tlw.shutdown)
       end
       # Wait for all the logging threads to move files to buckets
       threads.flatten.compact.each do |thread|
         thread.join
       end
+      @tlws.each do |_topic, tlw|
+        tlw.cleanup
+      end
       super()
     end
   end

data/lib/openc3/migrations/20260204000000_remove_decom_reducer.rb

@@ -23,6 +23,8 @@ module OpenC3
         target_models = TargetModel.all(scope: scope)
         target_models.each do |name, target_model|
           # Remove deprecated decom log settings from target model
+          target_model.delete("cmd_unique_id_mode")
+          target_model.delete("tlm_unique_id_mode")
           target_model.delete("cmd_decom_log_cycle_time")
           target_model.delete("cmd_decom_log_cycle_size")
           target_model.delete("cmd_decom_log_retain_time")

data/lib/openc3/models/activity_model.rb

@@ -18,6 +18,7 @@
 # https://www.rubydoc.info/gems/redis/Redis/Commands/SortedSets
 
 require 'openc3/models/model'
+require 'openc3/models/timeline_model'
 require 'openc3/topics/timeline_topic'
 require 'securerandom'
 
@@ -28,6 +29,11 @@ module OpenC3
 
   class ActivityModel < Model
     MAX_DURATION = Time::SEC_PER_DAY
+    # Grace window (in seconds) to allow creating activities slightly in the past.
+    # This handles race conditions where real-time activity notifications arrive
+    # after the start time has already passed (e.g. from external systems).
+    # This is consistent with the -15 second window in the timeline microservice.
+    START_GRACE_SECONDS = 15
     PRIMARY_KEY = '__openc3_timelines'.freeze # MUST be equal to `TimelineModel::PRIMARY_KEY` minus the leading __
     # See run_activity(activity) in openc3/lib/openc3/microservices/timeline_microservice.rb
     VALID_KINDS = %w(command script reserve expire)
@@ -212,7 +218,7 @@ module OpenC3
     end
 
     # validate the input to the rules we have created for timelines.
-    # - A task's start MUST NOT be in the past.
+    # - A task's start MUST NOT be more than START_GRACE_SECONDS in the past.
     # - A task's start MUST be before the stop.
     # - A task CAN NOT be longer than MAX_DURATION (86400) in seconds.
     # - A task MUST have a kind.
@@ -230,8 +236,8 @@ module OpenC3
       rescue NoMethodError
         raise ActivityInputError.new "start and stop must be seconds: #{start}, #{stop}"
       end
-      if now_f >= start and kind != 'expire'
-        raise ActivityInputError.new "activity must be in the future, current_time: #{now_f} vs #{start}"
+      if now_f >= start + START_GRACE_SECONDS and kind != 'expire'
+        raise ActivityInputError.new "activity must not be more than #{START_GRACE_SECONDS} seconds in the past, current_time: #{now_f} vs #{start}"
       elsif duration > MAX_DURATION and kind != 'expire'
         raise ActivityInputError.new "activity can not be longer than #{MAX_DURATION} seconds"
       elsif duration <= 0
@@ -262,6 +268,12 @@ module OpenC3
     # Update the Redis hash at primary_key and set the score equal to the start Epoch time
     # the member is set to the JSON generated via calling as_json
     def create(overlap: true, username: nil)
+      # Validate that the timeline exists in this scope before creating activities.
+      # Activities must be attached to an existing timeline within the same scope.
+      unless TimelineModel.get(name: @name, scope: @scope)
+        raise ActivityError.new "timeline '#{@name}' does not exist in scope '#{@scope}'"
+      end
+
       if @recurring['end'] and @recurring['frequency'] and @recurring['span']
         # First validate the initial recurring activity ... all others are just offsets
         validate_input(start: @start, stop: @stop, kind: @kind, data: @data)

data/lib/openc3/models/cvt_model.rb

@@ -15,11 +15,10 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
-require 'set'
 require 'openc3/utilities/store'
 require 'openc3/utilities/store_queued'
 require 'openc3/utilities/questdb_client'
-require 'openc3/models/target_model'
+# require 'openc3/models/target_model' # Circular require
 
 module OpenC3
   class CvtModel
@@ -126,251 +125,7 @@ module OpenC3
     end
 
     def self.tsdb_lookup(items, start_time:, end_time: nil, scope: $openc3_scope)
-      tables = {}
-      names = []
-      nil_count = 0
-      # Cache packet definitions to avoid repeated lookups
-      packet_cache = {}
-      # Map column names to item type info for decoding
-      item_types = {}
-      # Track calculated timestamp items: { position => { source:, format:, table_index: } }
-      calculated_items = {}
-      # Track which timestamp columns we need per table
-      needed_timestamps = {} # { table_index => Set of column names }
-      current_position = 0
-
-      # Stored timestamp items that need conversion from timestamp_ns to float seconds
-      stored_timestamp_items = Set.new(['PACKET_TIMESECONDS', 'RECEIVED_TIMESECONDS'])
-      # Track stored timestamp items: { position => { column:, table_index: } }
-      stored_timestamp_positions = {}
-
-      items.each do |item|
-        target_name, packet_name, orig_item_name, value_type, limits = item
-        # They will all be nil when item is a nil value
-        # A nil value indicates a value that does not exist as returned by get_tlm_available
-        if orig_item_name.nil?
-          # We know PACKET_TIMESECONDS always exists so we can use it to fill in the nil value
-          names << "PACKET_TIMESECONDS as __nil#{nil_count}"
-          nil_count += 1
-          current_position += 1
-          next
-        end
-        table_name = QuestDBClient.sanitize_table_name(target_name, packet_name, scope: scope)
-        tables[table_name] = 1
-        index = tables.find_index {|k,v| k == table_name }
-
-        # Check if this is a stored timestamp item (PACKET_TIMESECONDS or RECEIVED_TIMESECONDS)
-        # These are stored as timestamp_ns columns and need conversion to float seconds on read
-        if stored_timestamp_items.include?(orig_item_name)
-          col_name = "T#{index}.#{orig_item_name}"
-          names << "\"#{col_name}\""
-          stored_timestamp_positions[current_position] = { column: col_name, table_index: index }
-          current_position += 1
-          next
-        end
-
-        # Check if this is a calculated timestamp item (PACKET_TIMEFORMATTED or RECEIVED_TIMEFORMATTED)
-        if QuestDBClient::TIMESTAMP_ITEMS.key?(orig_item_name)
-          ts_info = QuestDBClient::TIMESTAMP_ITEMS[orig_item_name]
-          calculated_items[current_position] = {
-            source: ts_info[:source],
-            format: ts_info[:format],
-            table_index: index
-          }
-          # Track that we need this timestamp column for this table
-          needed_timestamps[index] ||= Set.new
-          needed_timestamps[index] << ts_info[:source]
-          current_position += 1
-          next
-        end
-
-        safe_item_name = QuestDBClient.sanitize_column_name(orig_item_name)
-
-        # Look up item type info from packet definition
-        cache_key = [target_name, packet_name]
-        unless packet_cache.key?(cache_key)
-          begin
-            packet_cache[cache_key] = TargetModel.packet(target_name, packet_name, scope: scope)
-          rescue RuntimeError
-            packet_cache[cache_key] = nil
-          end
-        end
-
-        packet_def = packet_cache[cache_key]
-        item_def = nil
-        if packet_def
-          packet_def['items']&.each do |pkt_item|
-            if pkt_item['name'] == orig_item_name
-              item_def = pkt_item
-              break
-            end
-          end
-        end
-
-        case value_type
-        when 'FORMATTED', 'WITH_UNITS'
-          col_name = "T#{index}.#{safe_item_name}__F"
-          names << "\"#{col_name}\""
-          # Formatted values are always strings, no special decoding needed
-          item_types[col_name] = { 'data_type' => 'STRING', 'array_size' => nil }
-        when 'CONVERTED'
-          col_name = "T#{index}.#{safe_item_name}__C"
-          names << "\"#{col_name}\""
-          # Converted values may have different types based on read_conversion
-          if item_def
-            rc = item_def['read_conversion']
-            if rc && rc['converted_type']
-              item_types[col_name] = { 'data_type' => rc['converted_type'], 'array_size' => item_def['array_size'] }
-            elsif item_def['states']
-              # State values are strings
-              item_types[col_name] = { 'data_type' => 'STRING', 'array_size' => nil }
-            else
-              item_types[col_name] = { 'data_type' => item_def['data_type'], 'array_size' => item_def['array_size'] }
-            end
-          else
-            item_types[col_name] = { 'data_type' => nil, 'array_size' => nil }
-          end
-        else
-          col_name = "T#{index}.#{safe_item_name}"
-          names << "\"#{col_name}\""
-          if item_def
-            item_types[col_name] = { 'data_type' => item_def['data_type'], 'array_size' => item_def['array_size'] }
-          else
-            item_types[col_name] = { 'data_type' => nil, 'array_size' => nil }
-          end
-        end
-        current_position += 1
-        if limits
-          names << "\"T#{index}.#{safe_item_name}__L\""
-        end
-      end
-
-      # Add needed timestamp columns to the SELECT
-      # Track which column alias maps to which timestamp source for result processing
-      # Note: We use underscores in the alias name to avoid needing quotes, which QuestDB includes in returned field names
-      timestamp_columns = {} # { "T0___ts_timestamp" => { table_index: 0, source: 'timestamp' } }
-      needed_timestamps.each do |table_index, ts_columns|
-        ts_columns.each do |ts_col|
-          alias_name = "T#{table_index}___ts_#{ts_col}"
-          names << "T#{table_index}.#{ts_col} as #{alias_name}"
-          timestamp_columns[alias_name] = { table_index: table_index, source: ts_col }
-        end
-      end
-
-      # Build the SQL query
-      query = "SELECT #{names.join(", ")} FROM "
-      tables.each_with_index do |(table_name, _), index|
-        if index == 0
-          query += "#{table_name} as T#{index} "
-        else
-          query += "ASOF JOIN #{table_name} as T#{index} "
-        end
-      end
-      query_params = []
-      if start_time && !end_time
-        query += "WHERE T0.PACKET_TIMESECONDS < $1 LIMIT -1"
-        query_params << start_time
-      elsif start_time && end_time
-        query += "WHERE T0.PACKET_TIMESECONDS >= $1 AND T0.PACKET_TIMESECONDS < $2"
-        query_params << start_time
-        query_params << end_time
-      end
-
-      retry_count = 0
-      begin
-        conn = QuestDBClient.connection
-        result = conn.exec_params(query, query_params)
-        if result.nil? or result.ntuples == 0
-          return {}
-        else
-          data = []
-          # Build up a results set that is an array of arrays
-          # Each nested array is a set of 2 items: [value, limits state]
-          # If the item does not have limits the limits state is nil
-          result.each_with_index do |tuples, row_num|
-            data[row_num] ||= []
-            row_index = 0
-            # Store timestamp values for this row: { "T0.PACKET_TIMESECONDS" => Time, ... }
-            row_timestamps = {}
-            tuples.each do |tuple|
-              col_name = 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 =~ /^T(\d+)___ts_(.+)$/
-                # This is a timestamp column for calculated items (TIMEFORMATTED)
-                table_idx = $1.to_i
-                ts_source = $2
-                row_timestamps["T#{table_idx}.#{ts_source}"] = col_value
-              elsif col_name.end_with?('.PACKET_TIMESECONDS', '.RECEIVED_TIMESECONDS') || col_name == 'PACKET_TIMESECONDS' || col_name == 'RECEIVED_TIMESECONDS'
-                # Stored timestamp column - convert from datetime to float seconds
-                ts_utc = QuestDBClient.pg_timestamp_to_utc(col_value)
-                seconds_value = QuestDBClient.format_timestamp(ts_utc, :seconds)
-                data[row_num][row_index] = [seconds_value, nil]
-                row_index += 1
-                # Also store for calculated items (TIMEFORMATTED) that may need this
-                # Normalize key to T{index}.{col} format for consistency
-                if col_name.include?('.')
-                  row_timestamps[col_name] = col_value
-                else
-                  row_timestamps["T0.#{col_name}"] = col_value
-                end
-              else
-                # Decode value using item type info
-                # QuestDB may return column names without table alias prefix
-                # Try both the raw column name and prefixed versions
-                type_info = item_types[col_name]
-                unless type_info
-                  tables.length.times do |i|
-                    prefixed_name = "T#{i}.#{col_name}"
-                    type_info = item_types[prefixed_name]
-                    break if type_info
-                  end
-                  type_info ||= {}
-                end
-                decoded_value = QuestDBClient.decode_value(
-                  col_value,
-                  data_type: type_info['data_type'],
-                  array_size: type_info['array_size']
-                )
-                data[row_num][row_index] = [decoded_value, nil]
-                row_index += 1
-              end
-            end
-
-            # Insert calculated timestamp items at their positions
-            # Insert in ascending order so positions remain valid after each insert
-            calculated_items.keys.sort.each do |position|
-              calc_info = calculated_items[position]
-              ts_key = "T#{calc_info[:table_index]}.#{calc_info[:source]}"
-              ts_value = row_timestamps[ts_key]
-              ts_utc = QuestDBClient.pg_timestamp_to_utc(ts_value)
-              calculated_value = QuestDBClient.format_timestamp(ts_utc, calc_info[:format])
-              data[row_num].insert(position, [calculated_value, nil])
-            end
-          end
-          # If we only have one row then we return a single array
-          if result.ntuples == 1
-            data = data[0]
-          end
-          return data
-        end
-      rescue IOError, PG::Error => e
-        # Retry the query because various errors can occur that are recoverable
-        retry_count += 1
-        if retry_count > 4
-          # After the 5th retry just raise the error
-          raise "Error querying TSDB: #{e.message}"
-        end
-        Logger.warn("TSDB: Retrying due to error: #{e.message}")
-        Logger.warn("TSDB: Last query: #{query}") # Log the last query for debugging
-        QuestDBClient.disconnect
-        sleep 0.1
-        retry
-      end
+      QuestDBClient.tsdb_lookup(items, start_time: start_time, end_time: end_time, scope: scope)
     end
 
     # Return all item values and limit state from the CVT

data/lib/openc3/models/plugin_model.rb

@@ -280,7 +280,15 @@ module OpenC3
                 pip_args = "-i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} -r #{requirements_path}"
               end
             end
-            puts `/openc3/bin/pipinstall #{pip_args}`
+            # Capture output and check exit code so failures surface as a warning
+            # rather than silently succeeding. pipinstall is non-fatal: the plugin
+            # continues to install even if Python packages fail so that non-Python
+            # functionality still works.
+            output = `/openc3/bin/pipinstall #{pip_args}`
+            puts output
+            unless $?.success?
+              Logger.warn "Python package installation failed. Plugin Python microservices may not function correctly."
+            end
           end
           needs_dependencies = true
         end

data/lib/openc3/models/plugin_store_model.rb

@@ -18,7 +18,7 @@ module OpenC3
   class PluginStoreModel < Model
     PRIMARY_KEY = 'openc3_plugin_store'
     DEFAULT_STORE_URL = 'https://store.openc3.com'
-    JSON_ENDPOINT = '/api/v1.1/cosmos_plugins'
+    JSON_ENDPOINT = '/api/v1.2/cosmos_plugins'
 
     def self.set(plugin_store_data)
       Store.set(PRIMARY_KEY, plugin_store_data)

data/lib/openc3/models/python_package_model.rb

@@ -99,7 +99,7 @@ module OpenC3
     def self.destroy(name, scope:)
       package_name, version = self.extract_name_and_version(name)
       Logger.info "Uninstalling package: #{name}"
-      pip_args = ["-y", package_name]
+      pip_args = [package_name]
       result = OpenC3::ProcessManager.instance.spawn(["/openc3/bin/pipuninstall"] + pip_args, "package_uninstall", name, Time.now + 3600.0, scope: scope)
       return result.name
     end