Am I making good use of ArenaAllocator or am I abusing it?

[pearl night]

fn getPatterns(allocator: std.mem.Allocator, dir: std.fs.Dir) [][]u8 {
    const file = dir.openFile(".gitignore", .{}) catch |err| {
        std.debug.print("Unable to open .gitignore: {s}\n", .{@typeName(@TypeOf(err))});
        return &.{};
    };
    defer file.close();

    const contents = file.readToEndAlloc(allocator, 1024 * 10) catch |err| {
        std.debug.print("Unable to read .gitignore: {s}\n", .{@typeName(@TypeOf(err))});
        return &.{};
    };
    defer allocator.free(contents);

    var patterns = std.ArrayList([]u8).init(allocator);

    var iterator = std.mem.split(u8, contents, "\n");
    while (iterator.next()) |pattern| {
        if (pattern.len == 0) continue;
        const copied = allocator.dupe(u8, pattern) catch |err| {
            std.debug.print("Error copying pattern '{s}': {s}\n", .{ pattern, @typeName(@TypeOf(err)) });
            continue;
        };
        patterns.append(copied) catch |err| {
            std.debug.print("Error appending pattern '{s}': {s}\n", .{ pattern, @typeName(@TypeOf(err)) });
            continue;
        };
    }

    return patterns.toOwnedSlice() catch &.{};
}```

fn getFilesInCurrentDir(gpa: std.mem.Allocator) GetFilesError!void {
    var arena = std.heap.ArenaAllocator.init(gpa);
    defer arena.deinit();
    const allocator = arena.allocator();

    var dir = std.fs.cwd().openDir(".", .{ .iterate = true }) catch {
        return GetFilesError.CantOpenCWD;
    };
    defer dir.close();

    const patterns = getPatterns(allocator, dir);

    var iter = dir.iterate();
    while (iter.next()) |maybe_entry| {
        const entry = maybe_entry orelse break;
        const name = entry.name;
        for (patterns) |p| {
            if (match(p, name)) continue;
        }
        std.debug.print("{s}\n", .{name});
    } else |err| {
        std.debug.print("Error while iterating through directory: {s}\n", .{@typeName(@TypeOf(err))});
    }
}```

If I use the GPA directly, I'd have to manually call free() in lots of places.

If I use Arena this way, I don't have to free() memory manually.

Is this a good use of Arena? Or am I digging a hole for myself?