Update all analysis references to topics

davidgisbey · davidgisbey · commit 1a43792983a9 · 2025-12-17T14:26:23.000Z
This goes through the codebase and updates all references from
"analysis" to "topics" where relevant.

Normally i'd:

- add a new table
- update the code to write to both tables
- backfill data from old table to new table
- switch over to the new table

But since we're currently not live I don't think it's necessary. API
users on integration may have momnentary issues but this should be
minimal.

I'll need to ensure I rename the tables on BigQuery before we run
our next export after this PR is merged.
diff --git a/app/controllers/admin/metrics_controller.rb b/app/controllers/admin/metrics_controller.rb
@@ -104,7 +104,7 @@ def question_routing_guardrails_failures
   end
 
   def topics
-    scope = AnswerAnalysis.joins(:answer)
+    scope = AnswerTopics.joins(:answer)
                           .where(answer: { created_at: start_time.. })
 
     primary_topic_scope = scope.where.not(primary_topic: nil)
diff --git a/app/controllers/admin/questions_controller.rb b/app/controllers/admin/questions_controller.rb
@@ -7,7 +7,7 @@ def index
   def show
     question_scope = Question.includes(
       conversation: :signon_user,
-      answer: [{ sources: :chunk }, :feedback, :analysis],
+      answer: [{ sources: :chunk }, :feedback, :topics],
     )
 
     @question = question_scope.find(params[:id])
diff --git a/app/jobs/answer_topics_job.rb b/app/jobs/answer_topics_job.rb
@@ -3,21 +3,21 @@ class AnswerTopicsJob < ApplicationJob
   retry_on Anthropic::Errors::APIError, wait: 1.minute, attempts: MAX_RETRIES
 
   def perform(answer_id)
-    answer = Answer.includes(:analysis, question: :conversation).find_by(id: answer_id)
+    answer = Answer.includes(:topics, question: :conversation).find_by(id: answer_id)
 
     return logger.warn("No answer found for #{answer_id}") unless answer
-    return logger.warn("Answer #{answer_id} has already been tagged with topics") if answer.analysis&.primary_topic.present?
+    return logger.warn("Answer #{answer_id} has already been tagged with topics") if answer.topics.present?
     unless answer.eligible_for_topic_analysis?
       return logger.info("Answer #{answer_id} is not eligible for topic analysis")
     end
 
-    result = AnswerAnalysisGeneration::TopicTagger.call(answer.rephrased_question || answer.question.message)
-    analysis = answer.build_analysis(
+    result = TopicTagger.call(answer.rephrased_question || answer.question.message)
+    topics = answer.build_topics(
       primary_topic: result.primary_topic,
       secondary_topic: result.secondary_topic,
+      llm_response: result.llm_response,
+      metrics: result.metrics,
     )
-    analysis.assign_metrics("topic_tagger", result.metrics)
-    analysis.assign_llm_response("topic_tagger", result.llm_response)
-    analysis.save!
+    topics.save!
   end
 end
diff --git a/app/models/admin/filters/questions_filter.rb b/app/models/admin/filters/questions_filter.rb
@@ -30,7 +30,7 @@ def initialize(...)
 
   def results
     @results ||= begin
-      scope = Question.includes(answer: %i[feedback analysis])
+      scope = Question.includes(answer: %i[feedback topics])
                       .left_outer_joins(:answer)
       scope = search_scope(scope)
       scope = status_scope(scope)
@@ -152,15 +152,15 @@ def question_routing_label_scope(scope)
   def primary_topic_scope(scope)
     return scope if primary_topic.blank?
 
-    scope.joins(answer: :analysis)
-         .where(answer_analyses: { primary_topic: primary_topic })
+    scope.joins(answer: :topics)
+         .where(answer_topics: { primary_topic: primary_topic })
   end
 
   def secondary_topic_scope(scope)
     return scope if secondary_topic.blank?
 
-    scope.joins(answer: :analysis)
-         .where(answer_analyses: { secondary_topic: secondary_topic })
+    scope.joins(answer: :topics)
+         .where(answer_topics: { secondary_topic: secondary_topic })
   end
 
   def completeness_scope(scope)
diff --git a/app/models/answer.rb b/app/models/answer.rb
@@ -54,7 +54,7 @@ def self.response_for_question_routing_label(label)
   belongs_to :question
   has_many :sources, -> { order(relevancy: :asc) }, class_name: "AnswerSource"
   has_one :feedback, class_name: "AnswerFeedback"
-  has_one :analysis, class_name: "AnswerAnalysis"
+  has_one :topics, class_name: "AnswerTopics"
 
   enum :status,
        {
diff --git a/app/models/answer_topics.rb b/app/models/answer_topics.rb
@@ -1,6 +1,4 @@
-class AnswerAnalysis < ApplicationRecord
-  include LlmCallsRecordable
-
+class AnswerTopics < ApplicationRecord
   belongs_to :answer
 
   scope :exportable, lambda { |start_date, end_date|
@@ -10,6 +8,6 @@ class AnswerAnalysis < ApplicationRecord
   }
 
   def serialize_for_export
-    as_json(except: :llm_responses).merge("llm_responses" => llm_responses.to_json)
+    as_json(except: :llm_response).merge("llm_response" => llm_response.to_json)
   end
 end
diff --git a/app/views/admin/questions/_analysis_tab.html.erb b/app/views/admin/questions/_analysis_tab.html.erb
@@ -2,43 +2,39 @@
   items: [
     {
       field: "Primary topic",
-      value: analysis.primary_topic&.humanize,
+      value: topics.primary_topic&.humanize,
     },
     {
       field: "Secondary topic",
-      value: analysis.secondary_topic&.humanize,
+      value: topics.secondary_topic&.humanize,
     },
   ],
 } %>
 
-<% if analysis.llm_responses.present? %>
+<% if topics.llm_response.present? %>
   <%= render "govuk_publishing_components/components/details", {
     title: "LLM responses",
   } do %>
-    <% analysis.llm_responses.each do |namespace, response| %>
-      <h3 class="govuk-heading-m"><%= namespace %></h3>
-      <p class="govuk-body">
-        <%= render("components/code_snippet", content: JSON.pretty_generate(response)) %>
-      </p>
-    <% end %>
+    <h3 class="govuk-heading-m">Topic tagger</h3>
+    <p class="govuk-body">
+      <%= render("components/code_snippet", content: JSON.pretty_generate(topics.llm_response)) %>
+    </p>
   <% end %>
 <% end %>
 
-<% if analysis.metrics.present? %>
+<% if topics.metrics.present? %>
   <%= render "govuk_publishing_components/components/details", {
     title: "Metrics",
   } do %>
-    <% analysis.metrics.sort.each do |namespace, metrics| %>
-      <%= render "govuk_publishing_components/components/summary_list", {
-        title: namespace,
-        items: metrics.map do |metric, value|
-          {
-            field: metric,
-            value: value,
-          }
-        end,
-        borderless: true,
-      } %>
-    <% end %>
+    <%= render "govuk_publishing_components/components/summary_list", {
+      title: "Topic tagger",
+      items: topics.metrics.map do |metric, value|
+        {
+          field: metric,
+          value: value,
+        }
+      end,
+      borderless: true,
+    } %>
   <% end %>
 <% end %>
diff --git a/app/views/admin/questions/show.html.erb b/app/views/admin/questions/show.html.erb
@@ -38,9 +38,9 @@ content_for(:active_navigation_item, admin_questions_path)
     label: "Analysis",
     content: render(
       "analysis_tab",
-      analysis: @answer.analysis,
+      topics: @answer.topics,
     ),
-  } if @answer&.analysis.present?
+  } if @answer&.topics.present?
 %>
 
 <div class="govuk-grid-row">
diff --git a/config/initializers/inflections.rb b/config/initializers/inflections.rb
@@ -15,4 +15,5 @@
   inflect.acronym "OpenAI"
   inflect.plural "reason_for_visit", "reason_for_visit"
   inflect.plural "found_chat", "found_chat"
+  inflect.uncountable "answer_topics"
 end
diff --git a/lib/bigquery.rb b/lib/bigquery.rb
@@ -4,6 +4,6 @@ module Bigquery
   TABLES_TO_EXPORT = [
     ExportTable.new(name: "questions", time_partitioning_field: "created_at"),
     ExportTable.new(name: "answer_feedback", time_partitioning_field: "created_at"),
-    ExportTable.new(name: "answer_analysis", time_partitioning_field: "created_at"),
+    ExportTable.new(name: "answer_topics", time_partitioning_field: "created_at"),
   ].freeze
 end
diff --git a/lib/tasks/evaluation.rake b/lib/tasks/evaluation.rake
@@ -119,7 +119,7 @@ namespace :evaluation do
   task generate_topics_for_question: :environment do
     raise "Requires an INPUT env var" if ENV["INPUT"].blank?
 
-    result = AnswerAnalysisGeneration::TopicTagger.call(ENV["INPUT"])
+    result = TopicTagger.call(ENV["INPUT"])
 
     puts(result.to_json)
   end
diff --git a/lib/topic_tagger.rb b/lib/topic_tagger.rb
@@ -1,4 +1,4 @@
-class AnswerAnalysisGeneration::TopicTagger
+class TopicTagger
   Result = Data.define(:primary_topic,
                        :secondary_topic,
                        :metrics,
diff --git a/spec/factories/answer_factory.rb b/spec/factories/answer_factory.rb
@@ -6,7 +6,7 @@
     completeness { :complete }
     sources { [] }
     feedback { nil }
-    analysis { nil }
+    topics { nil }
 
     trait :with_sources do
       sources do
@@ -29,8 +29,8 @@
       feedback { build(:answer_feedback) }
     end
 
-    trait :with_analysis do
-      analysis { build(:answer_analysis) }
+    trait :with_topics do
+      topics { build(:answer_topics) }
     end
   end
 end
diff --git a/spec/factories/answer_topics.rb b/spec/factories/answer_topics.rb
@@ -1,5 +1,5 @@
 FactoryBot.define do
-  factory :answer_analysis do
+  factory :answer_topics do
     answer
     primary_topic { "Primary Topic" }
     secondary_topic { "Secondary Topic" }
diff --git a/spec/helpers/admin/questions_helper_spec.rb b/spec/helpers/admin/questions_helper_spec.rb
@@ -256,6 +256,6 @@ def returned_value(result, key)
   end
 
   def answer_from_db(answer)
-    Answer.includes(:sources, :feedback, :analysis).find(answer.id)
+    Answer.includes(:sources, :feedback, :topics).find(answer.id)
   end
 end
diff --git a/spec/jobs/answer_topics_job_spec.rb b/spec/jobs/answer_topics_job_spec.rb
@@ -3,7 +3,7 @@
   let(:answer) { create(:answer) }
   let(:question) { answer.question }
   let(:topic_tagger_result) do
-    AnswerAnalysisGeneration::TopicTagger::Result.new(
+    TopicTagger::Result.new(
       primary_topic: "business",
       secondary_topic: "benefits",
       metrics: {
@@ -16,36 +16,36 @@
     )
   end
 
-  before { allow(AnswerAnalysisGeneration::TopicTagger).to receive(:call).and_return(topic_tagger_result) }
+  before { allow(TopicTagger).to receive(:call).and_return(topic_tagger_result) }
 
   it_behaves_like "a job in queue", "default"
 
   describe "#perform" do
-    it "calls the AnswerAnalysisGeneration::TopicTagger with the answer message" do
+    it "calls the TopicTagger with the answer message" do
       described_class.new.perform(answer.id)
-      expect(AnswerAnalysisGeneration::TopicTagger).to have_received(:call).with(question.message)
+      expect(TopicTagger).to have_received(:call).with(question.message)
     end
 
-    it "creates an analysis for the answer based of the returned result" do
+    it "creates topics for the answer based of the returned result" do
       expect {
         described_class.new.perform(answer.id)
-      }.to change(AnswerAnalysis, :count).by(1)
-      expect(answer.reload.analysis)
+      }.to change(AnswerTopics, :count).by(1)
+      expect(answer.reload.topics)
         .to have_attributes(
           primary_topic: topic_tagger_result.primary_topic,
           secondary_topic: topic_tagger_result.secondary_topic,
-          metrics: { "topic_tagger" => topic_tagger_result.metrics },
-          llm_responses: { "topic_tagger" => topic_tagger_result.llm_response },
+          metrics: topic_tagger_result.metrics,
+          llm_response: topic_tagger_result.llm_response,
         )
     end
 
     context "when the answer has a rephrased_question" do
       let(:rephrased_question) { "This is a rephrased_question" }
 
-      it "calls the AnswerAnalysisGeneration::TopicTagger with the rephrased question" do
+      it "calls the TopicTagger with the rephrased question" do
         answer = create(:answer, rephrased_question: rephrased_question)
         described_class.new.perform(answer.id)
-        expect(AnswerAnalysisGeneration::TopicTagger).to have_received(:call).with(rephrased_question)
+        expect(TopicTagger).to have_received(:call).with(rephrased_question)
       end
     end
 
@@ -62,12 +62,12 @@
 
       it "doesn't call the TopicTagger" do
         described_class.new.perform(answer_id)
-        expect(AnswerAnalysisGeneration::TopicTagger).not_to have_received(:call)
+        expect(TopicTagger).not_to have_received(:call)
       end
     end
 
-    context "when the answer analysis has tagged topics" do
-      let(:answer) { create(:answer, :with_analysis) }
+    context "when topics have been tagged" do
+      let(:answer) { create(:answer, :with_topics) }
 
       it "logs a warning" do
         expect(described_class.logger)
@@ -80,7 +80,7 @@
 
     context "when TopicTagger raises an Anthropic::Errors::APIError" do
       it "retries the job the max number of times" do
-        allow(AnswerAnalysisGeneration::TopicTagger).to receive(:call)
+        allow(TopicTagger).to receive(:call)
           .and_raise(Anthropic::Errors::APIError.new(
                        url: "url",
                      ))
@@ -107,7 +107,7 @@
       end
 
       it "does not call the TopicTagger" do
-        expect(AnswerAnalysisGeneration::TopicTagger).not_to receive(:call)
+        expect(TopicTagger).not_to receive(:call)
         described_class.new.perform(answer.id)
       end
     end
diff --git a/spec/lib/tasks/bigquery_spec.rb b/spec/lib/tasks/bigquery_spec.rb
@@ -29,12 +29,12 @@
       previous_export = create(:bigquery_export, exported_until: 2.hours.ago)
       answer = create(:answer, created_at: 1.hour.ago)
       create(:answer_feedback, created_at: 1.hour.ago, answer:)
-      create(:answer_analysis, created_at: 1.hour.ago, answer:)
+      create(:answer_topics, created_at: 1.hour.ago, answer:)
 
       expected_counts = {
         "questions" => 1,
         "answer_feedback" => 1,
-        "answer_analysis" => 1,
+        "answer_topics" => 1,
       }
 
       tables_output = Bigquery::TABLES_TO_EXPORT.map do |table|
diff --git a/spec/lib/tasks/evaluation_spec.rb b/spec/lib/tasks/evaluation_spec.rb
@@ -384,13 +384,13 @@
 
     it "outputs the response as JSON to stdout" do
       ClimateControl.modify(INPUT: input) do
-        result = AnswerAnalysisGeneration::TopicTagger::Result.new(
+        result = TopicTagger::Result.new(
           primary_topic: "tax",
           secondary_topic: "benefits",
           metrics: {},
           llm_response: {},
         )
-        allow(AnswerAnalysisGeneration::TopicTagger).to receive(:call).with(input).and_return(result)
+        allow(TopicTagger).to receive(:call).with(input).and_return(result)
 
         expect { Rake::Task[task_name].invoke }
           .to output("#{result.to_json}\n").to_stdout
diff --git a/spec/lib/topic_tagger_spec.rb b/spec/lib/topic_tagger_spec.rb
@@ -1,4 +1,4 @@
-RSpec.describe AnswerAnalysisGeneration::TopicTagger, :aws_credentials_stubbed do
+RSpec.describe TopicTagger, :aws_credentials_stubbed do
   describe ".call" do
     let(:message) { "This is a test message." }
 
@@ -7,7 +7,7 @@
     it "returns a results object with the expected topics" do
       result = described_class.call(message)
       expect(result)
-        .to be_a(AnswerAnalysisGeneration::TopicTagger::Result)
+        .to be_a(TopicTagger::Result)
         .and have_attributes(
           primary_topic: "business",
           secondary_topic: "benefits",
diff --git a/spec/models/admin/filters/questions_filter_spec.rb b/spec/models/admin/filters/questions_filter_spec.rb
diff --git a/spec/models/answer_analysis_spec.rb b/spec/models/answer_analysis_spec.rb
diff --git a/spec/models/answer_topics_spec.rb b/spec/models/answer_topics_spec.rb
diff --git a/spec/requests/admin/metrics_spec.rb b/spec/requests/admin/metrics_spec.rb
diff --git a/spec/requests/admin/questions_spec.rb b/spec/requests/admin/questions_spec.rb
diff --git a/spec/system/admin/user_views_metrics_spec.rb b/spec/system/admin/user_views_metrics_spec.rb

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ def index`
`7`	`7`	`def show`
`8`	`8`	`question_scope = Question.includes(`
`9`	`9`	`conversation: :signon_user,`
`10`		`- answer: [{ sources: :chunk }, :feedback, :analysis],`
	`10`	`+ answer: [{ sources: :chunk }, :feedback, :topics],`
`11`	`11`	`)`
`12`	`12`
`13`	`13`	`@question = question_scope.find(params[:id])`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ def self.response_for_question_routing_label(label)`
`54`	`54`	`belongs_to :question`
`55`	`55`	`has_many :sources, -> { order(relevancy: :asc) }, class_name: "AnswerSource"`
`56`	`56`	`has_one :feedback, class_name: "AnswerFeedback"`
`57`		`- has_one :analysis, class_name: "AnswerAnalysis"`
	`57`	`+ has_one :topics, class_name: "AnswerTopics"`
`58`	`58`
`59`	`59`	`enum :status,`
`60`	`60`	`{`