Summary:

• This PR replaces the v4 module with the legacy v1 module and updates call sites accordingly.
• v4 and v1 have breaking API differences. The PR has already changed:
  • FilepathGlob(...) → Glob(...)
  • import path github.com/bmatcuk/doublestar/v4 → github.com/bmatcuk/doublestar
• One subtle but important behavioral difference to double-check is path separator normalization (especially on Windows) for exclude patterns and possibly for glob patterns.

Why review is needed:

• v4 introduced an explicitly named FilepathGlob (filepath/OS-specific semantics). In v1, the equivalent is Glob.
• Both versions expose PathMatch, but pattern/name separator handling differs if your pattern strings use forward slashes while the OS path separator is backslash (Windows). The current PR removes filepath.FromSlash(...) normalization around exclude patterns; that can change matching semantics on Windows.

Recommended code adjustments to preserve behavior:

• Keep normalizing exclude patterns to the OS path separator before calling PathMatch, as was done before. This avoids mismatches when config-supplied patterns use / on Windows.

Code changes:

1. internal/component/local/file_match/watch.go

-   matches, err := doublestar.Glob(w.getPath())
+   matches, err := doublestar.Glob(w.getPath())
    if err != nil {
        return nil, err
    }
    exclude := w.getExcludePath()
    for _, m := range matches {
        if exclude != "" {
-           if match, _ := doublestar.PathMatch(exclude, m); match {
+           // Normalize exclude to OS-specific separators to preserve previous behavior
+           if match, _ := doublestar.PathMatch(filepath.FromSlash(exclude), m); match {
                continue
            }
        }

2. internal/component/loki/source/file/resolver.go

-           matches, err := doublestar.Glob(targetPath)
+           matches, err := doublestar.Glob(targetPath)
            if err != nil {
                level.Error(s.logger).Log("msg", "failed to resolve target", "error", err)
                continue
            }

            for _, m := range matches {
                if exclude != "" {
-                   if match, _ := doublestar.PathMatch(exclude, m); match {
+                   // Normalize exclude to OS-specific separators to preserve previous behavior
+                   if match, _ := doublestar.PathMatch(filepath.FromSlash(exclude), m); match {
                        continue
                    }
                }

Optional hardening (only if your config patterns use forward slashes on Windows):

• If targets are user-configured with / separators, also normalize the glob pattern before calling Glob:

- matches, err := doublestar.Glob(targetPath)
+ matches, err := doublestar.Glob(filepath.FromSlash(targetPath))

Only apply this if you do accept /-separated patterns on Windows. If your config already provides OS-native separators, keep as-is.

Behavioral notes to verify with tests:

• Exclusion patterns on Windows still work as before when given with / separators (the normalization above preserves this).
• Recursive matching over ** and hidden files remains consistent with your expectations. v1 and v4 share doublestar semantics for these primitives for simple use cases like yours, but validate with a couple of representative patterns.
• You are no longer using any v4-only APIs (e.g., fs.FS-based globbing, option structs). Your code does not reference those, so this looks fine.

Evidence and references:

• v4 introduced an explicitly OS-aware FilepathGlob(...) API; v1 provides Glob(...) for file system globbing and PathMatch(...) for pattern checks. The code changes in this

🔍 Dependency Review

-   matches, err := doublestar.Glob(w.getPath())
+   matches, err := doublestar.Glob(w.getPath())
    if err != nil {
        return nil, err
    }
    exclude := w.getExcludePath()
    for _, m := range matches {
        if exclude != "" {
-           if match, _ := doublestar.PathMatch(exclude, m); match {
+           // Use OS-aware match and normalize pattern to OS separators
+           if match, _ := doublestar.Match(filepath.FromSlash(exclude), m); match {
                continue
            }
        }

-           matches, err := doublestar.Glob(targetPath)
+           matches, err := doublestar.Glob(targetPath)
            if err != nil {
                level.Error(s.logger).Log("msg", "failed to resolve target", "error", err)
                continue
            }

            for _, m := range matches {
                if exclude != "" {
-                   if match, _ := doublestar.PathMatch(exclude, m); match {
+                   // Use OS-aware match and normalize pattern to OS separators
+                   if match, _ := doublestar.Match(filepath.FromSlash(exclude), m); match {
                        continue
                    }
                }

- matches, err := doublestar.Glob(targetPath)
+ matches, err := doublestar.Glob(filepath.FromSlash(targetPath))

Notes

• Both github.com/bmatcuk/doublestar (v1) and github.com/bmatcuk/doublestar/v4 (v4) now appear in the workspace (v4 as indirect). Consider consolidating to a single major version to reduce ambiguity and binary size if possible.