Return the last coverage in trace stream

What does this MR do?

This MR fixes the coverage issue raised at https://gitlab.com/gitlab-org/gitlab-ce/issues/31556. Currently, the first coverage appears in the trace will be considered as the coverage. Since general total scores will likely appear at the last part of logs, coverage extraction should be targeting the last matched part.

Are there points in the code the reviewer needs to double check?

Need to be checked by @godfat

Why was this MR needed?

Because #31556 (closed) labeled as regression

Screenshots (if relevant)

Does this MR meet the acceptance criteria?

• Changelog entry added, if necessary
• Documentation created/updated
• API support added
• Tests
  • Added for this feature/bug
  • All builds are passing
• Conform by the merge request performance guides
• Conform by the style guides
• Branch has no merge conflicts with master (if it does - rebase it please)
• Squashed related commits together

What are the relevant issue numbers?

Closes #31556 (closed)

lib/gitlab/ci/trace/stream.rb

@@ -92,41 +92,32 @@ def extract_coverage(regex)
         private
 
         def read_last_lines(limit)
-          result = ''
-          reverse_line do |line|
-            result = line + result
-            limit -= 1
-            return result if limit <= 0
-          end
-          result
+          to_enum(:reverse_line).first(limit).reverse.join
         end
 
         def reverse_line
-          pos = BUFFER_SIZE
+          pos = 0
           max = stream.size
           debris = ''
+          
+          return if max <= 0
 
-          while pos < max
+          while (read_size = calc_read_size(pos, max)) > 0
+            pos += read_size
             stream.seek(-pos, IO::SEEK_END)
-            stream.read(BUFFER_SIZE).tap do |buf|
-              buf = buf + debris
-              debris, *lines = buf.each_line.to_a
-              lines.reverse_each do |line|
-                yield(line)
-              end
-            end
-            pos += BUFFER_SIZE
-          end
-
-          # Reached the head, read only left
-          stream.seek(0)
-          last = (max > BUFFER_SIZE) ? (max % BUFFER_SIZE) : max
-          stream.read(last).tap do |buf|
-            buf = buf + debris
-            buf.each_line.reverse_each do |line|
+            buf = stream.read(read_size) + debris
+            debris, *lines = buf.each_line.to_a
+            lines.reverse_each do |line|
               yield(line)
             end
           end
+
+          yield(debris)
+        end
+
+        def calc_read_size(pos, max)
+          remain = max - pos
+          (remain > BUFFER_SIZE) ? BUFFER_SIZE : remain
         end
       end
     end