What causes "error reading task for pid %d: %w" in prometheus/node_exporter?

Check the wrapped cause: permission errors mean the exporter user lacks access to the process's task directory — run as root or relax hidepid/LSM policy.

prometheus/node_exporter · error

error reading task for pid

Error message

error reading task for pid %d: %w

What it means

getThreadStates opens the task directory of a process (fs, err := procfs.NewFS / AllProcs on /proc/<pid>/task) to enumerate its threads; a non-ignored error reading the task entry is wrapped as 'error reading task for pid %d'. Missing-task errors (pid exited) are deliberately ignored and return nil.

Solutions

Check the wrapped cause: permission errors mean the exporter user lacks access to the process's task directory — run as root or relax hidepid/LSM policy.
If an LSM (SELinux/AppArmor) denies access, add an allow rule for node_exporter to read procfs.
Update procfs/node_exporter so more transient (process-exited) errors are classified as ignorable.
Identify the pid from logs and confirm with ls -l /proc/<pid>/task as the exporter user.

Defensive patterns

Strategy: try-catch

Validate before calling

// verify the exporter can traverse task directories
if _, err := os.ReadDir("/proc/1/task"); err != nil {
    log.Printf("cannot read /proc/1/task as exporter user: %v", err)
}

Try / catch

if err := c.Update(ch); err != nil {
    if errors.Is(err, os.ErrPermission) || errors.Is(err, os.ErrNotExist) {
        log.Printf("thread task read issue (permissions or pid exited): %v", err)
        // retry next scrape; only alert if persistent
    }
}

Prevention

Grant the exporter user read access to /proc/<pid>/task (root or hidepid gid option).
Add SELinux/AppArmor rules permitting procfs reads for node_exporter.
Keep procfs/node_exporter current so process-exit races return nil instead of errors.
Correlate errors with specific pids from the debug logs.

When it happens

Trigger: Reading /proc/<pid>/task for a pid fails with an error that c.isIgnoredError() does not treat as ignorable, e.g. EACCES/EPERM on the task directory during a scrape.

Common situations: hidepid-restricted procfs where the exporter cannot traverse another user's /proc/<pid>/task; SELinux/AppArmor denials; races where the process exited between listing and task read (these are normally silenced as ignored errors).

Understand the failure class

Background: "failed to read file", EACCES, ENOENT and "could not read <path>" errors: when a program can't read a file from disk — this error's family across 49 libraries.

Related errors

AI-assisted analysis of prometheus/node_exporter@17ddd77c59 (2026-09-07). Data as JSON: /api/errors/1b06c5d901c1b4f8. Report an issue: GitHub.

Appendix: source

Thrown at collector/processes_linux.go:156

		procStates[stat.State]++
		thread += stat.NumThreads
		err = c.getThreadStates(pid.PID, stat, threadStates)
		if err != nil {
			return 0, nil, 0, nil, err
		}
	}
	return pids, procStates, thread, threadStates, nil
}

func (c *processCollector) getThreadStates(pid int, pidStat procfs.ProcStat, threadStates map[string]int32) error {
	fs, err := procfs.NewFS(procFilePath(path.Join(strconv.Itoa(pid), "task")))
	if err != nil {
		if c.isIgnoredError(err) {
			c.logger.Debug("file not found when retrieving tasks for pid", "pid", pid, "err", err)
			return nil
		}
		c.logger.Debug("error reading tasks for pid", "pid", pid, "err", err)
		return fmt.Errorf("error reading task for pid %d: %w", pid, err)
	}

	t, err := fs.AllProcs()
	if err != nil {
		if c.isIgnoredError(err) {
			c.logger.Debug("file not found when retrieving tasks for pid", "pid", pid, "err", err)
			return nil
		}
		return fmt.Errorf("unable to list all threads for pid: %d %w", pid, err)
	}

	for _, thread := range t {
		if pid == thread.PID {
			threadStates[pidStat.State]++
			continue
		}
		threadStat, err := thread.Stat()
		if err != nil {

View on GitHub (pinned to 17ddd77c59)