Detecting and Preventing Memory Leaks in the Webman PHP Framework

Memory Leak Overview

A memory leak occurs when dynamically allocated heap memory is not released, leading to wasted RAM, slower performance, and potentially system crashes. Leaks are stealthy and accumulate over time, making them harder to detect than other memory errors.

Webman Framework Context

Webman is a resident‑memory (long‑running) PHP framework, so developers should be aware of possible leaks, although they typically arise only under extreme conditions and can be avoided.

When Does a Leak Occur?

A leak requires two conditions to be met simultaneously:

A long‑lived array (e.g., a static variable) that persists for the process lifetime.

The array expands without bound because the application continuously inserts data without cleaning it up.

If both conditions hold, memory usage will keep increasing; otherwise, the growth is normal and not a leak.

Static Array Example

The article uses a static $data array in a controller and runs a 30‑second load test with 100 concurrent requests using the ApiPost tool. The array grows with each request, illustrating unbounded expansion.

Faulty Code

class MemoryController
{
    /** @var array */
    public static array $data = [];

    public function list(): Response
    {
        for ($i = 0; $i < 100000; $i++) {
            self::$data[] = $i . ':' . time();
        }
        return response_json('ok', 0, self::$data);
    }
}

Running php start.php status before the test shows about 64 M memory usage. After the load test, the Summary field reports roughly 383 M, confirming a leak.

Correct Code

class MemoryController
{
    /** @var array */
    public array $data = [];

    public function list(): Response
    {
        for ($i = 0; $i < 100000; $i++) {
            $this->data[] = $i . ':' . time();
        }
        return response_json('ok', 0, $this->data);
    }
}

After replacing the static property with an instance property and rerunning the same load test, the memory usage remains around 64 M, showing that the leak is eliminated.

Conclusion

In Webman, a static array that lives for the entire process and continuously grows causes a memory leak. Using non‑static storage, clearing data, or limiting array size prevents unbounded memory consumption and keeps the application stable.