Merge branch 'feat/podcast_scorecards_dashboard' into feat/conditional_category_cards

Author: radical-ube

Gemfile.lock

@@ -577,6 +577,7 @@ PLATFORMS
   arm64-darwin-22
   arm64-darwin-23
   arm64-darwin-24
+  arm64-darwin-25
   x86_64-darwin-21
   x86_64-darwin-22
   x86_64-darwin-23

app/assets/stylesheets/app/badge.scss

@@ -26,6 +26,11 @@
   color: $black;
 }
 
+.prx-badge-not_publishable {
+  background: $gray-400;
+  color: $black;
+}
+
 .prx-badge-incomplete-published,
 .prx-badge-invalid,
 .prx-badge-not_found,

app/controllers/api/auth/uploads_controller.rb

@@ -12,7 +12,7 @@ def s3_signer
   end
 
   def show
-    opts = {bucket: s3_bucket, key: s3_key, use_accelerate_endpoint: s3_accelerate, expires_in: 30.minutes.to_i}
+    opts = {bucket: s3_bucket, key: s3_key, use_accelerate_endpoint: s3_accelerate, expires_in: 1.hour.to_i}
     exp = Time.now.to_i + opts[:expires_in]
     put_url = s3_signer.presigned_request(:put_object, opts)
     get_url = s3_signer.presigned_request(:get_object, opts)

app/controllers/errors_controller.rb

@@ -8,4 +8,8 @@ class ErrorsController < ActionController::Base
   def not_found
     render file: Rails.public_path.join("404.html"), status: :not_found
   end
+
+  def not_allowed
+    head :method_not_allowed
+  end
 end

app/controllers/podcast_metrics_controller.rb

@@ -13,9 +13,10 @@ def episode_sparkline
     @prev_episode = Episode.find_by(guid: metrics_params[:prev_episode_id])
 
     @episode_trend = calculate_episode_trend(@episode, @prev_episode)
+
     @sparkline_downloads =
       Rollups::HourlyDownload
-        .where(episode_id: @episode[:guid], hour: (@episode.first_rss_published_at..Date.utc_today))
+        .where(episode_id: @episode[:guid], hour: (publish_hour(@episode)..publish_hour(@episode) + 6.months))
         .final
         .select(:episode_id, "DATE_TRUNC('DAY', hour) AS hour", "SUM(count) AS count")
         .group(:episode_id, "DATE_TRUNC('DAY', hour) AS hour")
@@ -261,25 +262,33 @@ def metrics_params
   end
 
   def calculate_episode_trend(episode, prev_episode)
-    return nil unless episode.in_default_feed? && episode.first_rss_published_at.present? && prev_episode.present?
+    return nil unless episode.first_rss_published_at.present? && prev_episode.present?
     return nil if (episode.first_rss_published_at + 1.day) > Time.now
 
     ep_dropday_sum = episode_dropday_query(episode)
     previous_ep_dropday_sum = episode_dropday_query(prev_episode)
 
     return nil if ep_dropday_sum <= 0 || previous_ep_dropday_sum <= 0
 
-    ((ep_dropday_sum.to_f / previous_ep_dropday_sum.to_f) - 1).round(2)
+    ((ep_dropday_sum.to_f / previous_ep_dropday_sum.to_f) - 1).round(3)
   end
 
   def episode_dropday_query(ep)
-    lowerbound = ep.first_rss_published_at.beginning_of_hour
+    lowerbound = publish_hour(ep)
     upperbound = lowerbound + 24.hours
 
     Rollups::HourlyDownload
-      .where(episode_id: ep[:guid], hour: (lowerbound..upperbound))
+      .where(episode_id: ep[:guid], hour: (lowerbound...upperbound))
       .final
       .load_async
       .sum(:count)
   end
+
+  def publish_hour(episode)
+    if episode.first_rss_published_at.present?
+      episode.first_rss_published_at.beginning_of_hour
+    else
+      episode.published_at.beginning_of_hour
+    end
+  end
 end

app/controllers/podcasts_controller.rb

@@ -20,9 +20,11 @@ def show
 
     @recently_published_episodes = @podcast.episodes.published.dropdate_desc.limit(4)
     @trend_episodes = @podcast.default_feed.episodes.published.dropdate_desc.where.not(first_rss_published_at: nil).offset(1).limit(4)
-    @episode_trend_pairs = episode_trend_pairs(@recently_published_episodes, @trend_episodes)
-    @alltime_downloads = alltime_downloads(@podcast).sum(&:count)
-    @daterange_downloads = daterange_downloads(@podcast).sum(&:count)
+    if Rails.env.development?
+      @episode_trend_pairs = episode_trend_pairs(@recently_published_episodes, @trend_episodes)
+      @alltime_downloads = alltime_downloads(@podcast).sum(&:count)
+      @daterange_downloads = daterange_downloads(@podcast).sum(&:count)
+    end
     @episode_count = @podcast.episodes.published.length
 
     # @recently_published is used for the prod branch

app/helpers/episodes_helper.rb

@@ -16,19 +16,22 @@ def episode_explicit_options
   end
 
   def episode_integration_status(integration, episode)
+    return "not_publishable" unless episode.integration_feed_episode?(integration)
+
     status = episode.episode_delivery_status(integration, true)
+
     if !status
       "not_found"
     elsif status.new_record?
       "new"
     elsif !status.uploaded?
       "incomplete"
+    elsif episode.integration_error_state?(integration)
+      "error"
     elsif !status.delivered?
       "processing"
-    elsif status.delivered?
-      "complete"
     else
-      "not_found"
+      "complete"
     end
   end
 
@@ -38,31 +41,6 @@ def episode_integration_updated_at(integration, episode)
       episode.updated_at
   end
 
-  def episode_apple_status(episode)
-    apple_episode = episode.apple_episode
-    if !apple_episode
-      "not_found"
-    elsif apple_episode.apple_new?
-      "new"
-    elsif apple_episode.needs_delivery?
-      "incomplete"
-    elsif apple_episode.waiting_for_asset_state?
-      "processing"
-    elsif apple_episode.audio_asset_state_error?
-      "error"
-    elsif apple_episode.synced_with_apple?
-      "complete"
-    else
-      "not_found"
-    end
-  end
-
-  def episode_apple_updated_at(episode)
-    episode.apple_sync_log&.updated_at ||
-      episode.apple_status&.created_at ||
-      episode.updated_at
-  end
-
   def episode_status_class(episode)
     case episode.publishing_status_was
     when "draft"

app/helpers/metrics_helper.rb

@@ -17,13 +17,13 @@ def parse_trend(trend)
 
     if trend > 0
       {
-        percent: "+#{(trend * 100).round(2)}%",
+        percent: "+#{trend * 100}%",
         color: modified_trend_color(trend, "text-success"),
         direction: modified_trend_direction(trend, "up")
       }
     elsif trend < 0
       {
-        percent: "-#{(trend * -100).round(2)}%",
+        percent: "-#{trend * -100}%",
         color: modified_trend_color(trend, "text-danger"),
         direction: modified_trend_direction(trend, "down")
       }

app/models/apple/episode.rb

@@ -478,6 +478,14 @@ def audio_asset_state_error?
       audio_asset_state == AUDIO_ASSET_FAILURE
     end
 
+    def delivery_file_errors?
+      podcast_delivery_files.any?(&:processed_errors?)
+    end
+
+    def error_state?
+      audio_asset_state_error? || delivery_file_errors?
+    end
+
     def audio_asset_state_success?
       audio_asset_state == AUDIO_ASSET_SUCCESS
     end

app/models/apple/publisher.rb

@@ -91,18 +91,15 @@ def publish!
 
     def upload_and_process!(eps)
       Rails.logger.tagged("Apple::Publisher#upload_and_process!") do
-        eps.filter(&:apple_needs_upload?).each_slice(PUBLISH_CHUNK_LEN) do |eps|
-          upload_media!(eps)
+        eps.filter(&:apple_needs_upload?).each_slice(PUBLISH_CHUNK_LEN) do |batch|
+          upload_media!(batch)
         end
 
-        eps.filter(&:apple_needs_delivery?).each_slice(PUBLISH_CHUNK_LEN) do |eps|
-          process_delivery!(eps)
+        eps.filter(&:apple_needs_delivery?).each_slice(PUBLISH_CHUNK_LEN) do |batch|
+          process_delivery!(batch)
         end
 
-        eps.each_slice(PUBLISH_CHUNK_LEN) do |eps|
-          publish_drafting!(eps)
-          raise_delivery_processing_errors(eps)
-        end
+        raise_delivery_processing_errors(eps)
       end
     end
 
@@ -145,9 +142,11 @@ def process_delivery!(eps)
         wait_for_upload_processing(eps)
 
         # Wait for the audio asset to be processed by Apple
-        # Mark episodes as delivered as they are processed
         wait_for_asset_state(eps) do |ready_eps|
           log_asset_wait_duration!(ready_eps)
+          # Publish the ready episodes
+          publish_drafting!(ready_eps)
+          # Then mark them as delivered
           mark_as_delivered!(ready_eps)
         end
       end
@@ -398,11 +397,47 @@ def mark_as_uploaded!(eps)
       end
     end
 
+    def verify_publishing_state!(eps)
+      # Capture initial state before polling to detect drift
+      initial_states = eps.to_h { |ep| [ep.feeder_id, ep.publishing_state] }
+
+      poll_episodes!(eps)
+
+      drifted_count = eps.count do |ep|
+        initial_state = initial_states[ep.feeder_id]
+        (ep.publishing_state != initial_state).tap do |drifted|
+          if drifted
+            Rails.logger.warn("Episode publishing state found to be out of sync", {
+              episode_id: ep.feeder_id,
+              local_expected_state: initial_state,
+              remote_actual_state: ep.publishing_state
+            })
+          end
+        end
+      end
+
+      if drifted_count.positive?
+        raise Apple::RetryPublishingError.new("Detected #{drifted_count} episodes with publishing state drift")
+      end
+
+      true
+    end
+
     def publish_drafting!(eps)
       Rails.logger.tagged("##{__method__}") do
-        eps = eps.select { |ep| ep.drafting? && ep.container_upload_complete? }
+        # Guard: verify all episodes are in a consistent local and remote state
+        verify_publishing_state!(eps)
+
+        drafting_eps, non_ready_eps = eps.partition { |ep| ep.drafting? && ep.container_upload_complete? }
+        non_ready_eps.each do |ep|
+          Rails.logger.info("Skipping publish for non-ready episode", {episode_id: ep.feeder_id,
+                                                                     publishing_state: ep.publishing_state,
+                                                                     container_upload_complete: ep.container_upload_complete?})
+        end
+
+        Rails.logger.info("Publishing #{drafting_eps.length} drafting episodes.", {drafting_episode_ids: drafting_eps.map(&:feeder_id)}) if drafting_eps.any?
 
-        res = Apple::Episode.publish(api, show, eps)
+        res = Apple::Episode.publish(api, show, drafting_eps)
 
         Rails.logger.info("Published #{res.length} drafting episodes.")
       end