Improve Admin Log Viewer with reliable streaming and investigation workspace (#498)

* Improve admin log viewer with reliable tank.log streaming and investigation UI.

* Add hover tooltips explaining log viewer controls.

* Remove Cursor rules files from the repository.

* Remove CLAUDE.md from the repository.

* Ignore local Cursor and Claude agent config files.

* Add compact timeline clocks, gap deltas, and volume axis labels.

---------

Co-authored-by: zkofiro <zakaria_kofiro@intuit.com>

Author: Zakaria-Kofiro

.gitignore

@@ -179,3 +179,9 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# Local agent / IDE tooling (never commit)
+.cursor/
+CLAUDE.md
+AGENTS.md
+.codegraph/

rest-mvc/impl/src/main/java/com/intuit/tank/rest/mvc/rest/controllers/LogController.java

@@ -7,17 +7,15 @@
  */
 package com.intuit.tank.rest.mvc.rest.controllers;
 
+import com.intuit.tank.rest.mvc.rest.services.logs.LogFileResponse;
 import com.intuit.tank.rest.mvc.rest.services.logs.LogServiceV2;
 
 import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
-import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
 
 import jakarta.annotation.Resource;
 import java.io.IOException;
@@ -26,16 +24,21 @@
 @RequestMapping(value = "/v2/logs")
 @Tag(name = "Logs")
 public class LogController {
+    static final String TOTAL_LENGTH_HEADER = "X-Total-Content-Length";
+    static final String CONTENT_START_HEADER = "X-Content-Start";
+
     @Resource
     private LogServiceV2 logServiceV2;
 
     @RequestMapping(value = "/{filename}", method = RequestMethod.GET, produces = { MediaType.APPLICATION_OCTET_STREAM_VALUE })
     @Operation(description = "Retrieves a specific log file from logs", summary = "Get streaming log file output", hidden = true)
     public ResponseEntity<StreamingResponseBody> getFile(@PathVariable String filename, @RequestParam(required = false) String from) throws IOException {
-        StreamingResponseBody response = logServiceV2.getFile(filename, from);
+        LogFileResponse response = logServiceV2.getFile(filename, from);
 
         return ResponseEntity.ok()
                 .contentType(MediaType.APPLICATION_OCTET_STREAM)
-                .body(response);
+                .header(TOTAL_LENGTH_HEADER, Long.toString(response.totalLength()))
+                .header(CONTENT_START_HEADER, Long.toString(response.startOffset()))
+                .body(response.body());
     }
 }

rest-mvc/impl/src/main/java/com/intuit/tank/rest/mvc/rest/services/logs/LogFileResponse.java

@@ -0,0 +1,19 @@
+/**
+ *  Copyright 2015-2026 Intuit Inc.
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License v1.0
+ *  which accompanies this distribution, and is available at
+ *  http://www.eclipse.org/legal/epl-v10.html
+ */
+package com.intuit.tank.rest.mvc.rest.services.logs;
+
+import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
+
+/**
+ * Streaming log response and the byte range represented by its body.
+ */
+public record LogFileResponse(
+        StreamingResponseBody body,
+        long totalLength,
+        long startOffset) {
+}

rest-mvc/impl/src/main/java/com/intuit/tank/rest/mvc/rest/services/logs/LogServiceV2.java

@@ -10,8 +10,6 @@
 import com.intuit.tank.rest.mvc.rest.controllers.errors.GenericServiceResourceNotFoundException;
 import com.intuit.tank.rest.mvc.rest.controllers.errors.GenericServiceBadRequestException;
 import com.intuit.tank.rest.mvc.rest.controllers.errors.GenericServiceForbiddenAccessException;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
-
 public interface LogServiceV2 {
 
     /**
@@ -32,8 +30,8 @@ public interface LogServiceV2 {
      * @throws GenericServiceForbiddenAccessException
      *         if user not authorized to access file
      *
-     * @return streaming output of log file
+     * @return streaming output and byte-range metadata for the log file
      */
-    public StreamingResponseBody getFile(String filePath, String start);
+    LogFileResponse getFile(String filePath, String start);
 
 }

rest-mvc/impl/src/main/java/com/intuit/tank/rest/mvc/rest/services/logs/LogServiceV2Impl.java

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2015-2023 Intuit Inc.
+ *  Copyright 2015-2026 Intuit Inc.
  *  All rights reserved. This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License v1.0
  *  which accompanies this distribution, and is available at
@@ -11,53 +11,51 @@
 import com.intuit.tank.rest.mvc.rest.controllers.errors.GenericServiceForbiddenAccessException;
 import com.intuit.tank.rest.mvc.rest.controllers.errors.GenericServiceResourceNotFoundException;
 import com.intuit.tank.rest.mvc.rest.util.FileReader;
+import com.intuit.tank.rest.mvc.rest.util.LogDirectory;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
 
-import jakarta.servlet.ServletContext;
 import java.io.File;
 
 @Service
 public class LogServiceV2Impl implements LogServiceV2 {
 
-    @Autowired
-    private ServletContext servletContext;
-
     private static final Logger LOGGER = LogManager.getLogger(LogServiceV2Impl.class);
 
     @Override
-    public StreamingResponseBody getFile(String filePath, String start) {
-        StreamingResponseBody streamingResponse;
+    public LogFileResponse getFile(String filePath, String start) {
         start = start == null ? "0" : start;
         try {
-            if (filePath.contains("..") || filePath.startsWith("/")) {
+            if (filePath == null || filePath.contains("..") || filePath.startsWith("/") || filePath.contains("\\")) {
                 LOGGER.error("Error returning file: incorrect file path");
                 throw new GenericServiceBadRequestException("logs", "file path", "incorrect file path");
-            } else {
-                String rootDir = "logs";
-                final File f = new File(rootDir, filePath);
-                if (!f.exists()) {
-                    LOGGER.error("Error returning file: file does not exist");
-                    throw new GenericServiceResourceNotFoundException("logs", "file", null);
-                } else if (!f.isFile()) {
-                    LOGGER.error("Error returning file: not a file");
-                    throw new GenericServiceBadRequestException("logs", "file path", "not a file");
-                } else if (!f.canRead()) {
-                    LOGGER.error("Error returning file: user not authorized to access file");
-                    throw new GenericServiceForbiddenAccessException("logs", "file");
-                } else {
-                    long total = f.length();
-                    streamingResponse = FileReader.getFileStreamingResponseBody(f, total, start);
-                }
             }
+
+            final File f = LogDirectory.findFile(filePath);
+            if (f == null || !f.exists()) {
+                LOGGER.error("Error returning file: file does not exist in {}", LogDirectory.candidateRoots());
+                throw new GenericServiceResourceNotFoundException("logs", "file", null);
+            }
+            if (!f.isFile()) {
+                LOGGER.error("Error returning file: not a file");
+                throw new GenericServiceBadRequestException("logs", "file path", "not a file");
+            }
+            if (!f.canRead()) {
+                LOGGER.error("Error returning file: user not authorized to access file");
+                throw new GenericServiceForbiddenAccessException("logs", "file");
+            }
+
+            long total = f.length();
+            FileReader.FileStream stream = FileReader.getFileStream(f, total, start);
+            return new LogFileResponse(stream.body(), stream.totalLength(), stream.startOffset());
+        } catch (GenericServiceBadRequestException | GenericServiceResourceNotFoundException
+                | GenericServiceForbiddenAccessException e) {
+            throw e;
         } catch (Exception e) {
-            LOGGER.error("Error returning file: file could not be found");
+            LOGGER.error("Error returning file: file could not be found", e);
             throw new GenericServiceResourceNotFoundException("logs", "file", null);
         }
-        return streamingResponse;
     }
 }

rest-mvc/impl/src/main/java/com/intuit/tank/rest/mvc/rest/util/FileReader.java

@@ -8,23 +8,28 @@
 package com.intuit.tank.rest.mvc.rest.util;
 
 import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
-import org.apache.commons.io.FileUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.io.RandomAccessFile;
 import java.nio.channels.Channels;
 import java.nio.channels.FileChannel;
 import java.nio.channels.WritableByteChannel;
-import java.nio.charset.StandardCharsets;
-import java.util.Collections;
-import java.util.List;
 
 public final class FileReader {
 
+    private static final int TAIL_BUFFER_SIZE = 8192;
+
+    public record FileStream(
+            StreamingResponseBody body,
+            long totalLength,
+            long startOffset) {
+    }
+
     private FileReader() {
         // empty private constructor
     }
@@ -40,39 +45,49 @@ private FileReader() {
      *          file
      * 
      * @param total
-     *          total number of lines
+     *          total number of bytes
      *
      * @param start
-     *          starting line number
+     *          starting byte offset, or a negative number of lines from the end
      * 
      * @return a StreamingResponseBody
      */
-    public static StreamingResponseBody getFileStreamingResponseBody(final File f, long total, String start) {
+    public static FileStream getFileStream(final File f, long total, String start) {
+        final long from = resolveStartOffset(f, total, start);
+        final long count = total - from;
 
-        long l = 0;
-        if (start != null) {
-            try {
-                l = Long.parseLong(start);
-                // num lines to get from end
-                if (l < 0) {
-                    l = getStartChar(f, Math.abs(l), total);
-                }
-            } catch (Exception e) {
-                LOG.error("Error parsing start " + start + ": " + e);
+        StreamingResponseBody body = (final OutputStream output) -> {
+            try (FileInputStream inputStream = new FileInputStream(f);
+                 FileChannel inputChannel = inputStream.getChannel();
+                 WritableByteChannel outputChannel = Channels.newChannel(output)) {
+                inputChannel.transferTo(from, count, outputChannel);
             }
+        };
+        LOG.debug("returning data from " + from + " - " + total + " of total " + total);
+        return new FileStream(body, total, from);
+    }
+
+    public static StreamingResponseBody getFileStreamingResponseBody(final File f, long total, String start) {
+        return getFileStream(f, total, start).body();
+    }
+
+    private static long resolveStartOffset(File f, long total, String start) {
+        if (start == null) {
+            return 0;
         }
-        final long to = l > total ? 0 : total;
-        final long from = l;
 
-        StreamingResponseBody streamer = (final OutputStream output) -> {
-            try (FileChannel inputChannel = new FileInputStream(f).getChannel();
-                 WritableByteChannel outputChannel = Channels.newChannel(output)) {
-                inputChannel.transferTo(from, to, outputChannel);
+        try {
+            long requestedOffset = Long.parseLong(start);
+            if (requestedOffset < 0) {
+                return getStartByte(f, Math.abs(requestedOffset), total);
             }
-            // closing the channels
-        };
-        LOG.debug("returning data from " + from + " - " + to + " of total " + total);
-        return streamer;
+            // Offsets past EOF yield an empty slice at EOF so clients can detect
+            // truncation via X-Content-Start without replaying the whole file.
+            return Math.min(Math.max(0, requestedOffset), total);
+        } catch (Exception e) {
+            LOG.error("Error parsing start " + start + ": " + e);
+            return 0;
+        }
     }
 
     /**
@@ -82,18 +97,37 @@ public static StreamingResponseBody getFileStreamingResponseBody(final File f, l
      * @return
      * @throws IOException
      */
-    @SuppressWarnings({ "unchecked" })
-    private static long getStartChar(File f, long numLines, long total) throws IOException {
-        List<String> lines = FileUtils.readLines(f, StandardCharsets.UTF_8);
-        long count = 0;
-        if (lines.size() > numLines) {
-            Collections.reverse(lines);
-            for (int i = 0; i < numLines; i++) {
-                count += lines.get(i).length() + 1;
+    private static long getStartByte(File f, long numLines, long total) throws IOException {
+        if (numLines == 0 || total == 0) {
+            return 0;
+        }
+
+        long newlines = 0;
+        try (RandomAccessFile file = new RandomAccessFile(f, "r")) {
+            long blockEnd = total;
+            byte[] buffer = new byte[TAIL_BUFFER_SIZE];
+            while (blockEnd > 0) {
+                int blockLength = (int) Math.min(TAIL_BUFFER_SIZE, blockEnd);
+                long blockStart = blockEnd - blockLength;
+                file.seek(blockStart);
+                file.readFully(buffer, 0, blockLength);
+
+                for (int i = blockLength - 1; i >= 0; i--) {
+                    long position = blockStart + i;
+                    if (buffer[i] == '\n') {
+                        if (position == total - 1) {
+                            continue;
+                        }
+                        newlines++;
+                        if (newlines == numLines) {
+                            return position + 1;
+                        }
+                    }
+                }
+                blockEnd = blockStart;
             }
-            count = total - (count + 1);
         }
-        return count;
+        return 0;
     }
 
 }