Helpers/LwsLog.cpp at main · WebRTSP/Helpers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include "LwsLog.h"

#include <libwebsockets.h>

#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_sinks.h>


static std::shared_ptr<spdlog::logger> Logger;


static int PrepareLwsLogLevel(int maxLevel);
static void LwsLog(int level, const char* line);

void InitLwsLogger(spdlog::level::level_enum level)
{
    if(!Logger) {
        Logger = spdlog::stdout_logger_st("libwebsockets");
#ifdef SNAPCRAFT_BUILD
        Logger->set_pattern("[%n] [%l] %v");
#endif
    }

    Logger->set_level(level);

    int lwsLogLevel = LLL_ERR | LLL_WARN | LLL_NOTICE;
    switch(level) {
        case spdlog::level::trace:
            lwsLogLevel = PrepareLwsLogLevel(LLL_THREAD);
            break;
        case spdlog::level::debug:
            lwsLogLevel = PrepareLwsLogLevel(LLL_DEBUG);
            break;
        case spdlog::level::info:
            lwsLogLevel = PrepareLwsLogLevel(LLL_INFO);
            break;
        case spdlog::level::warn:
            lwsLogLevel = PrepareLwsLogLevel(LLL_WARN);
            break;
        case spdlog::level::err:
        case spdlog::level::critical:
            lwsLogLevel = PrepareLwsLogLevel(LLL_ERR);
            break;
        case spdlog::level::off:
            lwsLogLevel = 0;
            break;
        case spdlog::level::n_levels:
            break;
    }

    lws_set_log_level(lwsLogLevel, LwsLog);
}

static int PrepareLwsLogLevel(int maxLevel)
{
    int level = maxLevel;
    int outLevel = level;

    while(level > 1) {
        level >>= 1;
        outLevel |= level;
    }

    return outLevel;
}

static void LwsLog(int level, const char* line)
{
    if(nullptr == line)
        return;

    std::string logLines;
    size_t blockPos = 0;
    size_t pos = 0;
    for(; line[pos] != 0; ++pos) {
        if('\r' == line[pos]) {
            logLines.reserve(logLines.size() + pos - blockPos);
            logLines.append(line + blockPos, pos - blockPos);
            blockPos = pos + 1;
        }
    }

    if(blockPos < pos - 1) {
        logLines.reserve(logLines.size() + pos - blockPos);
        logLines.append(line + blockPos, pos - blockPos);
    }

    const std::string::size_type lastChar = logLines.find_last_not_of('\n');
    if(std::string::npos == lastChar)
        return;

    logLines.resize(lastChar + 1);

    if(logLines.empty())
        return;

    switch(level) {
        case LLL_ERR:
            Logger->error(logLines);
            break;
        case LLL_WARN:
            Logger->warn(logLines);
            break;
        case LLL_NOTICE:
        case LLL_INFO:
            Logger->info(logLines);
            break;
        case LLL_DEBUG:
            Logger->debug(logLines);
            break;
        case LLL_PARSER:
        case LLL_HEADER:
        case LLL_EXT:
        case LLL_CLIENT:
        case LLL_LATENCY:
        case LLL_USER:
        case LLL_THREAD:
        default:
            Logger->trace(logLines);
            break;
    }
}

static inline const std::shared_ptr<spdlog::logger>& LwsLog()
{
    if(!Logger) {
#ifdef NDEBUG
        InitLwsLogger(spdlog::level::info);
#else
        InitLwsLogger(spdlog::level::debug);
#endif
    }

    return Logger;
}