Bound the diagnostic log and cut the per-file scan noise
This commit is contained in:
1 parent
8f28c69df7
commit
89508a372a
10 files changed
+282
-38
No files matched your search
+11
-1
@@ -22,6 +22,16 @@ std::wstring utf8_to_wide(const std::string& text) {
|
||||
return out;
|
||||
}
|
||||
|
||||
// A library scan probes every container in the library, and most of them are
|
||||
// declined; they also mostly share a directory, so the path would spend the log's
|
||||
// byte budget repeating the same prefix once per file. The file name is what
|
||||
// identifies the line. Files this component claims are logged with their full
|
||||
// path by the caller.
|
||||
std::string file_name_of(const std::string& path) {
|
||||
const std::string::size_type slash = path.find_last_of("\\/");
|
||||
return (slash == std::string::npos) ? path : path.substr(slash + 1);
|
||||
}
|
||||
|
||||
// A bounded, read-only view of the file. Every accessor returns false instead of
|
||||
// throwing, so a truncated or hostile file simply fails the probe.
|
||||
class Window {
|
||||
@@ -534,7 +544,7 @@ Result scan(const std::string& path, std::size_t max_bytes) {
|
||||
} else {
|
||||
result = scan_mp4(file, max_bytes);
|
||||
}
|
||||
joc_log::line("container: %s -> %s (eac3=%d audio#%u codec=%s)", path.c_str(),
|
||||
joc_log::line("container: %s -> %s (eac3=%d audio#%u codec=%s)", file_name_of(path).c_str(),
|
||||
result.detail.c_str(), result.eac3 ? 1 : 0, result.audio_index,
|
||||
result.codec.empty() ? "-" : result.codec.c_str());
|
||||
return result;
|
||||
|
||||
+37
-10
@@ -17,6 +17,8 @@
|
||||
#include <SDK/input_impl.h>
|
||||
#include <SDK/tag_processor.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <cstdarg>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
@@ -66,6 +68,31 @@ std::string file_name_of(const std::string& path) {
|
||||
return slash == std::string::npos ? path : path.substr(slash + 1);
|
||||
}
|
||||
|
||||
// A library scan opens every container in the library through open(), and all but
|
||||
// a few of them are declined because their audio is not E-AC-3 JOC. The per-file
|
||||
// lines are what makes a scan diagnosable -- "the file that should have been
|
||||
// claimed was not, and here is why" -- but a large library is hundreds of
|
||||
// thousands of them, so a running summary is logged as well. It is short enough
|
||||
// to survive the log rolling over, which is what a scan of that size makes it do.
|
||||
constexpr unsigned kDeclineSummaryEvery = 1000;
|
||||
std::atomic<unsigned> g_declined{0};
|
||||
std::atomic<unsigned> g_claimed{0};
|
||||
|
||||
// One place for "this file is not ours". The message stays the caller's, so a
|
||||
// decline that failed rather than decided still reads as one.
|
||||
void decline(const char* fmt, ...) {
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
joc_log::line_v(fmt, args);
|
||||
va_end(args);
|
||||
|
||||
const unsigned count = g_declined.fetch_add(1, std::memory_order_relaxed) + 1;
|
||||
if ((count % kDeclineSummaryEvery) == 0u) {
|
||||
joc_log::line("scan: %u file(s) declined, %u claimed so far", count,
|
||||
g_claimed.load(std::memory_order_relaxed));
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tags of a file this component has taken over.
|
||||
//
|
||||
@@ -200,8 +227,7 @@ public:
|
||||
try {
|
||||
m_native_path = filesystem::g_get_native_path(m_path.c_str());
|
||||
} catch (const pfc::exception& error) {
|
||||
joc_log::line("decoder: not a native file path (%s): %s", m_path.c_str(),
|
||||
error.what());
|
||||
decline("decoder: not a native file path (%s): %s", m_path.c_str(), error.what());
|
||||
throw exception_io_unsupported_format();
|
||||
}
|
||||
|
||||
@@ -249,10 +275,11 @@ public:
|
||||
|
||||
if (scan.joc != joc_eac3::JocState::kYes) {
|
||||
// Hand the file to the next entry in the priority table.
|
||||
joc_log::line("decoder: yielding to the built-in decoder (%s)", scan.detail);
|
||||
decline("decoder: yielding to the built-in decoder (%s)", scan.detail);
|
||||
throw exception_io_unsupported_format();
|
||||
}
|
||||
joc_log::line("decoder: claiming this file as E-AC-3 JOC (bare stream)");
|
||||
g_claimed.fetch_add(1, std::memory_order_relaxed);
|
||||
m_input_kind = joc_decode::InputKind::kBare;
|
||||
}
|
||||
|
||||
@@ -263,8 +290,8 @@ public:
|
||||
void open_container(const char* extension) {
|
||||
m_container = joc_container::scan(m_native_path.get_ptr());
|
||||
if (!m_container.eac3) {
|
||||
joc_log::line("decoder: yielding to the built-in decoder (%s)",
|
||||
m_container.detail.c_str());
|
||||
decline("decoder: yielding to the built-in decoder (%s)",
|
||||
m_container.detail.c_str());
|
||||
throw exception_io_unsupported_format();
|
||||
}
|
||||
|
||||
@@ -273,20 +300,20 @@ public:
|
||||
std::string detail;
|
||||
if (!joc_decode::probe_container_joc(settings.ffmpeg_path, m_native_path.get_ptr(),
|
||||
m_container.audio_index, &joc, &detail)) {
|
||||
joc_log::line("decoder: cannot examine the E-AC-3 track (%s); yielding",
|
||||
detail.c_str());
|
||||
decline("decoder: cannot examine the E-AC-3 track (%s); yielding", detail.c_str());
|
||||
throw exception_io_unsupported_format();
|
||||
}
|
||||
if (!joc) {
|
||||
joc_log::line("decoder: yielding to the built-in decoder (E-AC-3 track %u carries "
|
||||
"no JOC: %s)",
|
||||
m_container.audio_index, detail.c_str());
|
||||
decline("decoder: yielding to the built-in decoder (E-AC-3 track %u carries "
|
||||
"no JOC: %s)",
|
||||
m_container.audio_index, detail.c_str());
|
||||
throw exception_io_unsupported_format();
|
||||
}
|
||||
|
||||
joc_log::line("decoder: claiming this file as E-AC-3 JOC (%s, audio track %u, .%s)",
|
||||
joc_container::kind_name(m_container.kind), m_container.audio_index,
|
||||
extension);
|
||||
g_claimed.fetch_add(1, std::memory_order_relaxed);
|
||||
m_input_kind = joc_decode::InputKind::kContainer;
|
||||
m_audio_index = m_container.audio_index;
|
||||
}
|
||||
|
||||
+81
-22
@@ -16,12 +16,20 @@ FILE* g_file = nullptr;
|
||||
bool g_opened = false;
|
||||
std::string g_path; // UTF-8, for reporting
|
||||
std::wstring g_wide_path; // for _wfopen
|
||||
unsigned long long g_lines = 0;
|
||||
bool g_capped = false;
|
||||
std::wstring g_wide_rolled; // g_wide_path with the .1 suffix
|
||||
unsigned long long g_bytes = 0;
|
||||
|
||||
// A Media Library scan calls into us for every file; the cap keeps a long
|
||||
// session from filling the disk, and says so once when it is reached.
|
||||
constexpr unsigned long long kMaxLines = 500000;
|
||||
// A Media Library scan calls into us for every file it walks, so the cap has to
|
||||
// be on bytes: the lines a scan produces run from 40 to 2048 bytes each, and a
|
||||
// cap on their number leaves the file they build unpredictable by a factor of
|
||||
// fifty. Sixteen mebibytes per file, one previous file kept, so the component
|
||||
// never holds more than 32 MiB of log.
|
||||
constexpr unsigned long long kMaxBytes = 16ull << 20;
|
||||
|
||||
// The lines recorded between header_begin() and header_end(): the version
|
||||
// banner, a handful of lines written once per process.
|
||||
bool g_recording = false;
|
||||
std::string g_header;
|
||||
|
||||
std::wstring module_directory() {
|
||||
HMODULE module = nullptr;
|
||||
@@ -64,6 +72,7 @@ void open_locked() {
|
||||
g_wide_path = dir + L"\\joc_decoder.log";
|
||||
}
|
||||
|
||||
g_wide_rolled = g_wide_path + L".1";
|
||||
g_path = to_utf8(g_wide_path);
|
||||
g_file = _wfopen(g_wide_path.c_str(), L"wb");
|
||||
if (g_file == nullptr) {
|
||||
@@ -74,6 +83,52 @@ void open_locked() {
|
||||
std::setvbuf(g_file, nullptr, _IONBF, 0);
|
||||
}
|
||||
|
||||
// Composes one line with its timestamp, writes it, and accounts for it. Returns
|
||||
// the bytes written, 0 when there was nowhere to write them.
|
||||
unsigned long long write_locked(const char* text) {
|
||||
if (g_file == nullptr) return 0;
|
||||
|
||||
SYSTEMTIME now;
|
||||
GetLocalTime(&now);
|
||||
char composed[2100];
|
||||
const int length =
|
||||
std::snprintf(composed, sizeof(composed), "%02u:%02u:%02u.%03u [t%05lu] %s\n", now.wHour,
|
||||
now.wMinute, now.wSecond, now.wMilliseconds,
|
||||
static_cast<unsigned long>(GetCurrentThreadId()), text);
|
||||
if (length <= 0) return 0;
|
||||
// snprintf reports the length it would have needed, which for a truncated
|
||||
// line is past the end of the buffer.
|
||||
const std::size_t size = (static_cast<std::size_t>(length) < sizeof(composed))
|
||||
? static_cast<std::size_t>(length)
|
||||
: sizeof(composed) - 1;
|
||||
std::fwrite(composed, 1, size, g_file);
|
||||
g_bytes += size;
|
||||
if (g_recording) g_header.append(composed, size);
|
||||
return size;
|
||||
}
|
||||
|
||||
// Moves the full file aside and starts an empty one. Called with the mutex held,
|
||||
// once the budget is spent. The banner is written again afterwards, so a log
|
||||
// that has rolled still opens with the versions it was produced by.
|
||||
void roll_locked() {
|
||||
std::fclose(g_file);
|
||||
g_file = nullptr;
|
||||
// One previous window, replaced rather than chained: a chain of rolls would
|
||||
// be the same unbounded log under another name. A move that fails -- the .1
|
||||
// file held open by a reader -- leaves the truncation below to bound the file
|
||||
// anyway, at the cost of the window that would have been kept.
|
||||
MoveFileExW(g_wide_path.c_str(), g_wide_rolled.c_str(), MOVEFILE_REPLACE_EXISTING);
|
||||
g_file = _wfopen(g_wide_path.c_str(), L"wb");
|
||||
if (g_file == nullptr) return;
|
||||
std::setvbuf(g_file, nullptr, _IONBF, 0);
|
||||
g_bytes = 0;
|
||||
write_locked("[log rolled: the previous window is in the .1 file beside this one]");
|
||||
if (!g_header.empty()) {
|
||||
std::fwrite(g_header.c_str(), 1, g_header.size(), g_file);
|
||||
g_bytes += g_header.size();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void open() {
|
||||
@@ -86,30 +141,34 @@ const char* path() {
|
||||
return g_path.c_str();
|
||||
}
|
||||
|
||||
void line(const char* fmt, ...) {
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
unsigned long long budget_bytes() { return kMaxBytes; }
|
||||
|
||||
void line_v(const char* fmt, va_list args) {
|
||||
char text[2048];
|
||||
std::vsnprintf(text, sizeof(text), fmt, args);
|
||||
va_end(args);
|
||||
|
||||
std::lock_guard<std::mutex> guard(g_mutex);
|
||||
if (!g_opened) open_locked();
|
||||
if (g_file == nullptr) return;
|
||||
if (g_lines >= kMaxLines) {
|
||||
if (!g_capped) {
|
||||
g_capped = true;
|
||||
std::fputs("[log capped]\n", g_file);
|
||||
}
|
||||
return;
|
||||
}
|
||||
++g_lines;
|
||||
if (write_locked(text) != 0 && g_bytes >= kMaxBytes) roll_locked();
|
||||
}
|
||||
|
||||
SYSTEMTIME now;
|
||||
GetLocalTime(&now);
|
||||
std::fprintf(g_file, "%02u:%02u:%02u.%03u [t%05lu] %s\n", now.wHour, now.wMinute,
|
||||
now.wSecond, now.wMilliseconds,
|
||||
static_cast<unsigned long>(GetCurrentThreadId()), text);
|
||||
void line(const char* fmt, ...) {
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
line_v(fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
void header_begin() {
|
||||
std::lock_guard<std::mutex> guard(g_mutex);
|
||||
g_header.clear();
|
||||
g_recording = true;
|
||||
}
|
||||
|
||||
void header_end() {
|
||||
std::lock_guard<std::mutex> guard(g_mutex);
|
||||
g_recording = false;
|
||||
}
|
||||
|
||||
} // namespace joc_log
|
||||
@@ -4,10 +4,22 @@
|
||||
// harness and so that it is safe to call from any thread the core queries us on.
|
||||
//
|
||||
// Path: %JOC_LOG% if set, otherwise <directory of this DLL>\joc_decoder.log.
|
||||
// The file is truncated once per process, line-buffered, and every line is
|
||||
// flushed so the log can be read while foobar2000 is still running.
|
||||
// The file is truncated once per process, unbuffered, and every line is written
|
||||
// straight out so the log can be read while foobar2000 is still running.
|
||||
//
|
||||
// Size: what is bounded is bytes, not lines. A line is anywhere between 40 and
|
||||
// 2048 bytes, so a cap on the number of lines leaves the size of the file
|
||||
// unpredictable by a factor of fifty. A file that reaches budget_bytes() is
|
||||
// moved to <path>.1 -- replacing any previous roll, so there is never a chain of
|
||||
// them -- and a fresh one is started. Two files of the budget is therefore the
|
||||
// most the component ever holds, and the newest lines are always the ones in
|
||||
// <path>. Lines written between header_begin() and header_end() are written
|
||||
// again at the top of every window, so a rolled log still says which build
|
||||
// produced it.
|
||||
#pragma once
|
||||
|
||||
#include <cstdarg>
|
||||
|
||||
namespace joc_log {
|
||||
|
||||
// Opens (truncating) the log. Called lazily by line(); call it explicitly to
|
||||
@@ -17,7 +29,18 @@ void open();
|
||||
// Absolute path of the log file, or "" when it could not be opened.
|
||||
const char* path();
|
||||
|
||||
// Bytes one file holds before it is rolled to <path>.1.
|
||||
unsigned long long budget_bytes();
|
||||
|
||||
// printf-style, thread safe, appends one line.
|
||||
void line(const char* fmt, ...);
|
||||
|
||||
// The va_list form, for a wrapper that forwards its own arguments.
|
||||
void line_v(const char* fmt, va_list args);
|
||||
|
||||
// Remembers the lines written in between and writes them again after every roll.
|
||||
// Meant for the version banner: a handful of lines, written once.
|
||||
void header_begin();
|
||||
void header_end();
|
||||
|
||||
} // namespace joc_log
|
||||
@@ -30,6 +30,9 @@ class joc_initquit : public initquit {
|
||||
public:
|
||||
void on_init() override {
|
||||
joc_log::open();
|
||||
// Recorded, so that a log which has rolled still opens with the versions
|
||||
// it was produced by.
|
||||
joc_log::header_begin();
|
||||
joc_log::line("=== foo_input_joc %s ===", JOC_VERSION);
|
||||
joc_log::line("foobar2000 core : %s", core_version_info::g_get_version_string());
|
||||
joc_log::line("component file : %s", core_api::get_my_file_name());
|
||||
@@ -37,6 +40,8 @@ public:
|
||||
joc_log::line("portable mode : %s",
|
||||
core_api::is_portable_mode_enabled() ? "yes" : "no");
|
||||
joc_log::line("log file : %s", joc_log::path());
|
||||
joc_log::line("log limit : %llu byte(s) per file, then rolled to the .1 suffix",
|
||||
joc_log::budget_bytes());
|
||||
joc_log::line("compiled as : %s",
|
||||
#if defined(_M_IX86)
|
||||
"x86 (32-bit)"
|
||||
@@ -46,6 +51,7 @@ public:
|
||||
"other"
|
||||
#endif
|
||||
);
|
||||
joc_log::header_end();
|
||||
}
|
||||
|
||||
void on_quit() override { joc_log::line("=== foo_input_joc shutdown ==="); }
|
||||
|
||||
Reference in new issue
Block a user