tests: add test for ignore_active_older_files re-pickup on mtime update

Add flb_test_in_tail_ignore_active_older_files_reread_on_update to verify
that a file excluded by ignore_active_older_files is re-picked up once its
mtime is refreshed by a new write, and that reading resumes from the stored
offset (only new content is delivered, not a re-read from the beginning).

Uses rotate_wait=1s and refresh_interval=1s to exercise the purge and scan
callbacks within a reasonable test window. Sets
read_newly_discovered_files_from_head=false so that ctx->read_from_head
stays false for scan-discovered files. Waits for msg1 to be consumed
before starting the aging clock to avoid a flaky saved-offset race on slow
machines. Uses wait_expected_num_with_timeout instead of fixed sleeps for
synchronisation points that have observable output signals.
expected=2: 1 for the initial msg1 read, 1 for msg2 picked up after
re-add at the stored offset.

Signed-off-by: zshuang0316 <zshuang0316@163.com>
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: zshuang0316

plugins/in_tail/tail_scan_glob.c

@@ -258,6 +258,15 @@ static int tail_scan_path(const char *path, struct flb_tail_config *ctx)
                         continue;
                     }
                 }
+                else {
+                    /* Different inode at the same path: the stored offset
+                     * belongs to the old file and must not be applied to the
+                     * replacement file. */
+                    flb_tail_scan_unregister_ignored_file_size(
+                        ctx,
+                        globbuf.gl_pathv[i],
+                        strlen(globbuf.gl_pathv[i]));
+                }
 
                 flb_tail_scan_unregister_aged_out_inode(
                     ctx,

plugins/in_tail/tail_scan_win32.c

@@ -116,6 +116,11 @@ static int tail_register_file(const char *target, struct flb_tail_config *ctx,
                 return -1;
             }
         }
+        else {
+            /* Different inode at the same path: the stored offset belongs to
+             * the old file and must not be applied to the replacement file. */
+            flb_tail_scan_unregister_ignored_file_size(ctx, path, strlen(path));
+        }
 
         flb_tail_scan_unregister_aged_out_inode(ctx, path, strlen(path));
     }

tests/runtime/in_tail.c

@@ -2038,6 +2038,106 @@ void flb_test_in_tail_ignore_active_older_files()
     test_tail_ctx_destroy(ctx);
 }
 
+/*
+ * Verify that a file excluded by ignore_active_older_files is re-picked up
+ * once its mtime is refreshed by a new write.
+ *
+ * Sequence:
+ *   1. Write msg1  → engine reads it (count = 1)
+ *   2. Wait 4 s    → purge fires (rotate_wait=1s), file is >2s old; inode
+ *                    registered as aged-out and file removed from monitoring
+ *   3. Write msg2  → mtime is now fresh
+ *   4. Wait 3 s    → scan fires (refresh_interval=1s), sees fresh mtime;
+ *                    unregisters aged-out entry and re-adds file at the
+ *                    stored offset (file->offset saved at age-out time);
+ *                    engine reads only msg2 (count += 1)
+ *   5. Assert count == 2
+ */
+void flb_test_in_tail_ignore_active_older_files_reread_on_update()
+{
+    struct flb_lib_out_cb cb_data;
+    struct test_tail_ctx *ctx;
+    char *file[] = {"source_file_reread.log"};
+    char *path = "source_file_reread.log";
+    char *msg = "TEST LINE";
+    const int expected = 2;
+    const int expected_before_rotate = 1;
+    int ret;
+    int num;
+    int unused;
+
+    clear_output_num();
+
+    cb_data.cb = cb_count_msgpack;
+    cb_data.data = &unused;
+
+    ctx = test_tail_ctx_create(&cb_data, &file[0], sizeof(file)/sizeof(char *), FLB_TRUE);
+    if (!TEST_CHECK(ctx != NULL)) {
+        TEST_MSG("test_ctx_create failed");
+        return;
+    }
+
+    ret = flb_input_set(ctx->flb, ctx->o_ffd,
+                        "path",                               path,
+                        "ignore_older",                      "2s",
+                        "rotate_wait",                       "1s",
+                        "refresh_interval",                  "1s",
+                        "read_newly_discovered_files_from_head", "false",
+                        "ignore_active_older_files",         "on",
+                        NULL);
+    TEST_CHECK(ret == 0);
+
+    ret = flb_start(ctx->flb);
+    if (!TEST_CHECK(ret == 0)) {
+        test_tail_ctx_destroy(ctx);
+        return;
+    }
+
+    /* Write first message and allow it to be flushed */
+    ret = write_msg(ctx, msg, strlen(msg));
+    if (!TEST_CHECK(ret > 0)) {
+        test_tail_ctx_destroy(ctx);
+        return;
+    }
+
+    /* Wait until msg1 is consumed before starting the aging clock. */
+    wait_expected_num_with_timeout(5000, expected_before_rotate, &num);
+    if (!TEST_CHECK(num == expected_before_rotate)) {
+        TEST_MSG("msg1 not consumed in time. got=%d", num);
+        test_tail_ctx_destroy(ctx);
+        return;
+    }
+
+    /*
+     * Wait long enough for the purge callback (rotate_wait=1s) to fire and
+     * detect that the file's mtime is older than ignore_older=2s, which
+     * removes the file from monitoring and registers its inode as aged-out.
+     */
+    flb_time_msleep(4000);
+
+    /* Append new content: this updates mtime so the file is no longer old */
+    ret = write_msg(ctx, msg, strlen(msg));
+    if (!TEST_CHECK(ret > 0)) {
+        test_tail_ctx_destroy(ctx);
+        return;
+    }
+
+    /*
+     * Wait for the scan callback (refresh_interval=1s) to re-evaluate the
+     * aged-out entry, find the fresh mtime, unregister the entry, and
+     * re-add the file.  The file is re-added at the stored offset (the read
+     * position saved when the file was aged out), so only msg2 — the content
+     * that refreshed the mtime — is flushed (count += 1).
+     */
+    wait_expected_num_with_timeout(5000, expected, &num);
+
+    if (!TEST_CHECK(num == expected)) {
+        TEST_MSG("output num error. expect=%d got=%d", expected, num);
+    }
+
+    test_tail_ctx_destroy(ctx);
+}
+
 void flb_test_inotify_watcher_false()
 {
     struct flb_lib_out_cb cb_data;
@@ -2693,6 +2793,7 @@ TEST_LIST = {
     {"skip_empty_lines_crlf", flb_test_skip_empty_lines_crlf},
     {"ignore_older", flb_test_ignore_older},
     {"ignore_active_older_files", flb_test_in_tail_ignore_active_older_files},
+    {"ignore_active_older_files_reread_on_update", flb_test_in_tail_ignore_active_older_files_reread_on_update},
 #ifdef FLB_HAVE_INOTIFY
     {"inotify_watcher_false", flb_test_inotify_watcher_false},
 #endif /* FLB_HAVE_INOTIFY */