I'm just starting
to work on a logging library that everyone can use
to keep track of any sort of system information while the user is running our application. The simplest example so far is
to track Info, Warnings, and Errors.
I want all plugins
to be able
to use this feature, but since each developer might have a different idea of what's important
to report, I want
to keep this as generic as possible.
In the C++ world, I would normally use something like a stl::pair<string,string>
to act as a key value pair structure, and have a stl::list of these
to act as a "row" in the log. The log cache would then be a list<list<pair<string,string>>> (ugh!). This way, the developers can use a const
string key like INFO, WARNING, ERROR
to have a consistent naming for a column in the database (for SELECTing specific types of information).
I'd like the database
to be able
to deal with any number of distinct column names. For example, John might have an INFO row with a column called USER, and Bill might have an INFO row with a column called FILENAME. I want the log viewer
to be able
to display all information, and if one report doesn't have a value for INFO / FILENAME, those fields should just appear blank. So one option is
to use List<List<KeyValuePair<String,String>>, and the another is
to have the log library consumer somehow "register" its schema, and then have the database do an ALTER TABLE
to handle this situation. Yet another idea is
to have a table that's just for key value pairs, with a foreign key that maps the key value pairs back
to the original log entry.
I obviously don't want logging
to bog down the system, so I only lock the log cache
to make a copy of the data (and remove the already-copied data), then a background thread will dump the information
to the database.
My specific questions regarding this are:
Do you see any performance issues? In other words, have you ever tried something like this and found that certain things just don't work well in practice?
Is there a more .NETish way
to implement the key value pairs, other than List<List<KeyValuePair<String,String>>>?
Even if there is a way
to do #2 better, is the ALTER TABLE idea I proposed above a Bad Thing?
Would you recommend multiple databases over a single one? I don't yet have an idea of how frequently the log would get written
to, but we ideally would like
to have lots of low level information. Perhaps there should be a DB with a fixed schema only for the low level stuff, and then another DB that's more flexible for reporting information back
to users.
