Find And Fix Memory Leaks

A client engagement team at Ampcus inherited this task queue class from another vendor's codebase. QA flagged that a long-running worker process using this class grows its resident memory steadily over a multi-day soak test until it's OOM-killed, even though the queue itself never holds more than a few hundred pending tasks at once.

#include <iostream>
#include <string>
#include <vector>

class Task {
public:
    std::string payload;
    Task(std::string p) : payload(p) {}
};

class TaskQueue {
private:
    std::vector<Task*> pending;

public:
    void addTask(const std::string& payload) {
        Task* t = new Task(payload);
        pending.push_back(t);
    }

    void processAll() {
        for (Task* t : pending) {
            handle(t);
        }
        pending.clear();
    }

    void handle(Task* t) {
        if (t->payload.empty()) {
            return;
        }
        std::string* log = new std::string("processed: " + t->payload);
        std::cout << *log << std::endl;
    }

    ~TaskQueue() {
    }
};

How would you identify the memory leak in this snippet, and how would you resolve it? Explain your reasoning, not just the fix.