Logger for a Game Engine

So I'm making a logger for a program and it has 6 levels increasing severity and things I don't think its as memory efficient as it could be but I'm just getting into c++ and memory coding. I feel like if I want to put it in a file I cant view it with a text editor using something like JSON or XML.

This is the code in question

#include <iostream>
#include <fstream>
#include <ctime>

enum class LogLevel { GREY, BLUE, GREEN, YELLOW, ORANGE, RED };

std::ostream& operator<<(std::ostream& os, LogLevel level) {
    switch (level) {
    case LogLevel::GREY:
        os << "GREY";
        break;
    case LogLevel::BLUE:
        os << "BLUE";
        break;
    case LogLevel::GREEN:
        os << "GREEN";
        break;
    case LogLevel::YELLOW:
        os << "YELLOW";
        break;
    case LogLevel::ORANGE:
        os << "ORANGE";
        break;
    case LogLevel::RED:
        os << "RED";
        break;
    default:
        os << "UNKNOWN";
        break;
    }
    return os;
}


class Logger {
private:
    std::ofstream logFile;

    std::string getTimestamp() {
        std::time_t now = std::time(nullptr);
        struct tm timeInfo;
        localtime_s(&timeInfo, &now);

        char timestamp[20];
        std::strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", &timeInfo);
        return timestamp;
    }

    std::string getColorCode(LogLevel level) {
        switch (level) {
        case LogLevel::GREY:
            return "\033[90m"; // Grey
        case LogLevel::BLUE:
            return "\033[94m"; // Blue
        case LogLevel::GREEN:
            return "\033[92m"; // Green
        case LogLevel::YELLOW:
            return "\033[93m"; // Yellow
        case LogLevel::ORANGE:
            return "\033[91m"; // Orange
        case LogLevel::RED:
            return "\033[31m"; // Red
        default:
            return "\033[0m"; // Reset color
        }
    }

public:
    Logger(const std::string& filename) {
        logFile.open(filename, std::ios::out | std::ios::app);
    }

    ~Logger() {
        if (logFile.is_open()) {
            logFile.close();
        }
    }

    void log(LogLevel level, const std::string& message) {
        std::string color = getColorCode(level);

        // Print to console with color
        std::cout << getTimestamp() << " " << color << message << "\033[0m" << std::endl;

        // Write to file
        if (logFile.is_open()) {
            logFile << getTimestamp() << " " << message << std::endl;
        }
    }

    void trace(const std::string& message) {
        log(LogLevel::GREY, message);
    }

    void debug(const std::string& message) {
        log(LogLevel::BLUE, message);
    }

    void info(const std::string& message) {
        log(LogLevel::GREEN, message);
    }

    void warn(const std::string& message) {
        log(LogLevel::YELLOW, message);
    }

    void error(const std::string& message) {
        log(LogLevel::ORANGE, message);
    }

    void critical(const std::string& message) {
        log(LogLevel::RED, message);
    }
};
```