Diagnosing Memory Leaks in Node.js Workers

As a junior Node.js developer, your task is to understand and identify a basic memory leak in our `{{application_name}}` worker process. This worker is showing increasing memory usage over time. Your objective is to propose a simple plan to find a common leak type, such as an unclosed event listener or an unintentionally growing array. Use `clinic.js` to take a heap snapshot and look for objects that are accumulating. Provide a clear hypothesis, outline straightforward steps to capture data using `clinic.js`, and suggest a basic code fix. Assume you can restart the worker and reproduce the issue in a controlled test environment.

As a senior Node.js Platform Engineer, your task is to outline a comprehensive diagnostic and resolution strategy for a memory leak.

Context:
Our long-running Node.js worker process, `{{worker_process_description}}`, exhibits a steady increase in resident set size (RSS) over extended periods, despite stable workload and no apparent increase in active connections or processing volume. This trend indicates a memory leak that, if left unaddressed, will eventually lead to process instability or out-of-memory errors. Initial observations suggest the leak might be in the `{{suspected_leak_area}}` module or related to its interactions with external services or data structures.

Task:
Your objective is to provide a detailed, actionable plan to diagnose, identify, and resolve this memory leak. The plan should be highly prescriptive, leading directly to a specific code-level fix and offering strategies for future prevention. Focus on a diagnostic approach that is practical and reproducible.

Constraints:
The diagnostic approach must primarily utilize `clinic.js` (specifically `clinic doctor` for general profiling, `clinic heap` for heap snapshot analysis, and potentially `clinic bubbleprof` if CPU usage is also anomalous) and direct V8 heap snapshots for in-depth object retention analysis. Focus on identifying specific code patterns causing the leak. The proposed fix should be a concrete code example. Assume access to the worker's source code and a controlled test environment where the leak can be reproduced.

Output:
1.  **Hypothesis List**:
    Provide a ranked list of at least three plausible hypotheses for the memory leak, based on common Node.js leak patterns (e.g., unclosed event listeners, growing caches, global variables, closures capturing large scopes, unmanaged database connections/cursors). Each hypothesis should include a brief justification for its likelihood in a long-running worker context.

2.  **Ordered Investigation Steps**:
    Detail a step-by-step methodology for diagnosing the leak. This must include:
    *   **Setup and Instrumentation**: How to instrument the target worker process with `clinic.js` for data collection. Specify necessary `clinic.js` commands and environment variables.
    *   **Data Collection**: Guidance on collecting multiple heap snapshots over time using `clinic heap` or directly via V8 inspector. Explain the importance of capturing snapshots at different stages of the leak's progression.
    *   **Heap Snapshot Analysis**: Detailed instructions on analyzing the collected heap snapshot data. This should cover:
        *   Comparing

As a Node.js engineer, you need to quickly diagnose and fix a memory leak in our `{{worker_service_name}}` long-running worker. The resident set size is steadily increasing. Outline a concise plan using `clinic.js` and V8 heap snapshots to identify the root cause, propose a code-level fix, and suggest prevention methods. Focus on practical steps for data collection and analysis to resolve the leak efficiently. Assume access to source code and a reproducible test environment for `{{leak_scenario}}`.

Assume the role of a Lead Node.js Platform Architect, responsible for diagnosing and mitigating a critical memory leak in our `{{mission_critical_worker}}` process. The sustained RSS increase poses significant operational risk and potential compliance implications for data integrity. Develop a comprehensive plan that not only identifies the specific code-level defect using `clinic.js` and V8 heap snapshots, but also addresses risk assessment, stakeholder communication, and a post-mortem analysis framework. Your output must include: ranked hypotheses, detailed diagnostic steps (including data collection, heap analysis, and reproduction validation), a concrete code fix, and a section on long-term prevention strategies, architectural reviews, and documentation requirements for audit trails. Consider the impact of `{{compliance_standard}}` on resolution procedures.