Track student and class analytics events

Author: abcampo-iry

app/controllers/api/class_members_controller.rb

@@ -37,6 +37,7 @@ def create
 
       if result.success?
         @class_member = result[:class_members].first
+        track_class_students_added([@class_member])
         render :show, formats: [:json], status: :created
       else
         render json: result.slice(:error, :errors), status: :unprocessable_content
@@ -55,6 +56,7 @@ def create_batch
       if result.failure? && result[:error].include?('No valid school members provided')
         render json: result, status: :unprocessable_content
       else
+        track_class_students_added(result[:class_members])
         successful = result[:class_members].map { |m| { success: true, user_id: m.user_id } }
         errors = result[:errors].map { |user_id, error| { success: false, user_id:, error: } }
         render json: successful + errors
@@ -115,5 +117,19 @@ def list_teachers(school, teacher_ids)
         { school_teachers: [] }
       end
     end
+
+    def track_class_students_added(class_members)
+      Array(class_members).grep(ClassStudent).each do |class_student|
+        student_id = class_student.student_id || class_student.student&.id
+        next if student_id.blank?
+
+        track_event(
+          'Class - Student added',
+          school_id: @school.id,
+          class_id: @school_class.id,
+          student_id:
+        )
+      end
+    end
   end
 end

app/controllers/api/school_classes_controller.rb

@@ -157,7 +157,7 @@ def create_school_students(school_students_params, school_class)
       {
         school_students: school_students_result[:school_students],
         errors: school_students_result[:errors]
-      }
+      }.tap { track_created_school_students(school_students_result[:school_students], class_id: school_class.id) }
     end
 
     def assign_students_to_class(school_class, school_students)
@@ -172,6 +172,7 @@ def assign_students_to_class(school_class, school_students)
         { success: false, student_id: user_id, school_class_id: school_class.id, error: error }
       end
 
+      track_imported_class_students_added(school_class, class_members_result[:class_members])
       class_members_result[:class_members] + class_members_errors
     end
 
@@ -221,5 +222,32 @@ def import_school_students_params
     def school_owner?
       current_user.school_owner?(@school)
     end
+
+    def track_created_school_students(school_students, class_id: nil)
+      Array(school_students).each do |school_student|
+        next unless school_student[:success] && school_student[:created]
+
+        track_event(
+          'Student - Created',
+          school_id: @school.id,
+          class_id:,
+          student_id: school_student[:student].id
+        )
+      end
+    end
+
+    def track_imported_class_students_added(school_class, class_members)
+      Array(class_members).grep(ClassStudent).each do |class_student|
+        student_id = class_student.student_id || class_student.student&.id
+        next if student_id.blank?
+
+        track_event(
+          'Class - Student added',
+          school_id: @school.id,
+          class_id: school_class.id,
+          student_id:
+        )
+      end
+    end
   end
 end

app/controllers/api/school_students_controller.rb

@@ -27,6 +27,7 @@ def create
       )
 
       if result.success?
+        track_event('Student - Created', school_id: @school.id, student_id: result[:student_id]) if result[:student_id].present?
         head :no_content
       else
         render json: { error: result[:error] }, status: :unprocessable_content
@@ -86,7 +87,10 @@ def enqueue_batches(students)
       @batch.enqueue do
         students.each_slice(MAX_BATCH_CREATION_SIZE) do |student_batch|
           SchoolStudent::CreateBatch.call(
-            school: @school, school_students_params: student_batch, token: current_user.token
+            school: @school,
+            school_students_params: student_batch,
+            token: current_user.token,
+            actor_user_id: current_user.id
           )
         end
       end

app/jobs/create_students_job.rb

@@ -26,11 +26,14 @@ class ConcurrencyExceededForSchool < StandardError; end
 
   queue_as :create_students_job
 
-  def self.attempt_perform_later(school_id:, students:, token:)
-    perform_later(school_id:, students:, token:)
+  def self.attempt_perform_later(school_id:, students:, token:, actor_user_id: nil)
+    args = { school_id:, students:, token: }
+    args[:actor_user_id] = actor_user_id if actor_user_id.present?
+
+    perform_later(**args)
   end
 
-  def perform(school_id:, students:, token:)
+  def perform(school_id:, students:, token:, actor_user_id: nil)
     school = School.find(school_id)
     decrypted_students = StudentHelpers.decrypt_students(students)
     SafeguardingFlagService.create_for_token(token:, school:)
@@ -39,6 +42,22 @@ def perform(school_id:, students:, token:)
 
     responses[:created].each do |user_id|
       Role.student.create!(school_id:, user_id:)
+      track_student_created(school_id:, student_id: user_id, actor_user_id:)
     end
   end
+
+  private
+
+  def track_student_created(school_id:, student_id:, actor_user_id:)
+    return if actor_user_id.blank?
+
+    EventTracker.track!(
+      name: 'Student - Created',
+      user_id: actor_user_id,
+      properties: {
+        school_id:,
+        student_id:
+      }
+    )
+  end
 end

lib/concepts/school_student/create_batch.rb

@@ -5,9 +5,9 @@ class Error < StandardError; end
 
   class CreateBatch
     class << self
-      def call(school:, school_students_params:, token:)
+      def call(school:, school_students_params:, token:, actor_user_id: nil)
         response = OperationResponse.new
-        response[:job_id] = create_batch(school, school_students_params, token)
+        response[:job_id] = create_batch(school, school_students_params, token, actor_user_id)
         response
       rescue CreateStudentsJob::ConcurrencyExceededForSchool => e
         response[:error] = e
@@ -22,8 +22,8 @@ def call(school:, school_students_params:, token:)
 
       private
 
-      def create_batch(school, students, token)
-        job = CreateStudentsJob.attempt_perform_later(school_id: school.id, students:, token:)
+      def create_batch(school, students, token, actor_user_id)
+        job = CreateStudentsJob.attempt_perform_later(school_id: school.id, students:, token:, actor_user_id:)
         job&.job_id
       end
     end

spec/features/class_member/creating_a_batch_of_class_members_spec.rb

@@ -61,6 +61,23 @@
           expect(data).to include({ success: true, user_id: class_member[:user_id] })
         end
       end
+
+      it 'records class student added events for the student members only' do
+        post("/api/schools/#{school.id}/classes/#{school_class.id}/members/batch", headers:, params:)
+
+        events = Event.where(name: 'Class - Student added').order(:time)
+        expect(events.count).to eq(3)
+        expect(events.map(&:user_id)).to all(eq(teacher.id))
+        expect(events.map(&:properties)).to match_array(
+          students.map do |student|
+            {
+              'school_id' => school.id,
+              'class_id' => school_class.id,
+              'student_id' => student.id
+            }
+          end
+        )
+      end
     end
 
     context 'when adding an owner as another teacher' do

spec/features/class_member/creating_a_class_member_spec.rb

@@ -60,6 +60,21 @@
         expect(response_student).to eq(student_attributes)
       end
 
+      it 'records a class student added event' do
+        post("/api/schools/#{school.id}/classes/#{school_class.id}/members", headers:, params: student_params)
+
+        expect(Event.last).to have_attributes(
+          name: 'Class - Student added',
+          user_id: owner.id,
+          properties: {
+            'school_id' => school.id,
+            'class_id' => school_class.id,
+            'student_id' => student.id
+          },
+          time: be_within(1.second).of(Time.current)
+        )
+      end
+
       context 'when the student is already in the class' do
         before do
           school_class.students.create!({ student_id: student.id })
@@ -126,6 +141,12 @@
         expect(response_teacher).to eq(teacher_attributes)
       end
 
+      it 'does not record a class student added event' do
+        expect do
+          post("/api/schools/#{school.id}/classes/#{school_class.id}/members", headers:, params: teacher_params)
+        end.not_to change(Event, :count)
+      end
+
       context 'when the teacher is already in the class' do
         before do
           school_class.teachers.create!({ teacher_id: another_teacher.id })

spec/features/school_class/importing_a_school_class_spec.rb

@@ -301,6 +301,20 @@
       # Class members should be assigned successfully
       expect(response_data[:class_members]).to be_an(Array)
       expect(response_data[:class_members].length).to eq(2)
+
+      student_events = Event.where(name: 'Student - Created')
+      expect(student_events.map(&:properties)).to contain_exactly(
+        { 'school_id' => school.id, 'class_id' => response_data[:school_class][:id], 'student_id' => 'student-1-id' },
+        { 'school_id' => school.id, 'class_id' => response_data[:school_class][:id], 'student_id' => 'student-2-id' }
+      )
+      expect(student_events).to all(have_attributes(user_id: teacher.id, time: be_within(1.second).of(Time.current)))
+
+      class_member_events = Event.where(name: 'Class - Student added')
+      expect(class_member_events.map(&:properties)).to contain_exactly(
+        { 'school_id' => school.id, 'class_id' => response_data[:school_class][:id], 'student_id' => 'student-1-id' },
+        { 'school_id' => school.id, 'class_id' => response_data[:school_class][:id], 'student_id' => 'student-2-id' }
+      )
+      expect(class_member_events).to all(have_attributes(user_id: teacher.id, time: be_within(1.second).of(Time.current)))
     end
 
     it 'allows re-importing the same class (finds existing class)' do

spec/features/school_student/creating_a_school_student_spec.rb

@@ -38,6 +38,23 @@
     expect(response).to have_http_status(:no_content)
   end
 
+  it 'records a student created event' do
+    student_id = SecureRandom.uuid
+    stub_profile_api_create_school_student(user_id: student_id)
+
+    post("/api/schools/#{school.id}/students", headers:, params:)
+
+    expect(Event.last).to have_attributes(
+      name: 'Student - Created',
+      user_id: owner.id,
+      properties: {
+        'school_id' => school.id,
+        'student_id' => student_id
+      },
+      time: be_within(1.second).of(Time.current)
+    )
+  end
+
   it 'responds 204 No Content when the user is a school-teacher' do
     teacher = create(:teacher, school:)
     authenticated_in_hydra_as(teacher)

spec/jobs/create_students_job_spec.rb

@@ -8,6 +8,7 @@
   let(:token) { UserProfileMock::TOKEN }
   let(:school) { create(:verified_school) }
   let(:user_id) { create(:user).id }
+  let(:actor_user_id) { create(:owner, school:).id }
 
   let(:students) do
     [{
@@ -46,4 +47,18 @@
 
     expect(Role.student.where(school:, user_id:)).to exist
   end
+
+  it 'records a student created event when the actor is provided' do
+    described_class.perform_now(school_id: school.id, students:, token:, actor_user_id:)
+
+    expect(Event.last).to have_attributes(
+      name: 'Student - Created',
+      user_id: actor_user_id,
+      properties: {
+        'school_id' => school.id,
+        'student_id' => user_id
+      },
+      time: be_within(1.second).of(Time.current)
+    )
+  end
 end