Log / Instrumentation Class

I'm interested in a creating a - we'll call it - Log (or Instrumentation) class.  My initial thoughts on the log class capabilities are:
1.    A member function that'll take std::ostream as an argument and print all accumulated logs.
2.    File stream, cout and stringstream log capabilities.
3.    Time Stamping.
4.    class 'object' registeration.  My intent here is to obtain visibility into a class's member data.   For ex:
          class  X {
          public:
            void Increment() { idx++; }
          private:
            int idx;
         };

//later:
        X xx;
Now xx would get 'registered' with the log class.  This offers visibility into the member data idx.

-------------------------------------------------------------------------------------------------------------------------------------
I'm unsure of an approach to items 2 and 4.  For items 1 and 3, one solution is as follows:

   #include <iostream>
    #include <ctime>
    #include <iomanip>
    #include <vector>
    #include <algorithm>
    #include <functional>
    #include <iterator>
    #include <sstream>
    using namespace std;

    struct PlainPrintPolicy
    {
       static string print(const string& str) { return str; }
    };

    struct TimestampPrintPolicy
    {
       static string print(const string& str);
    };

    string TimestampPrintPolicy::print(const string& str)
    {
       ostringstream ostr;
       time_t now;
       time(&now);
       tm *current = localtime(&now);
       ostr.fill('0');
       ostr << "["
            << current->tm_year+1900 << "-"
          << setw(2) << current->tm_mon+1 << "-"
          << current->tm_mday << " " 
          << setw(2) << current->tm_hour << "."
          << setw(2) << current->tm_min << "."
          << setw(2) << current->tm_sec << "]: "
          << str;
       return ostr.str();
    }

    template <typename PrintPolicy>
    class Logger
    {
       public:
          void addEntry(const string& str)
        {
           store_.push_back(PrintPolicy::print(str));
        }
   
        void dumpLog(ostream& os)
        {
           copy(store_.begin(), store_.end(), ostream_iterator<string>(os, "\n"));
        }

       private:
          vector<string> store_;
    };

    int main()
    {
       Logger<PlainPrintPolicy> logger;
       logger.addEntry("System booted");
       logger.addEntry("FaultFaultFault");
       logger.addEntry("Shutdown");
       logger.dumpLog(cout);

       Logger<TimestampPrintPolicy> logger2;
       logger2.addEntry("System booted");
       logger2.addEntry("FaultFaultFault");
       logger2.addEntry("Shutdown");
       logger2.dumpLog(cout);

       return 0;
}

Of course, I'm open to more viable solution with source example.   Thanks in advance