libzypp: zypp-core/base/LogControl.cc Source File

libzypp 17.38.5

LogControl.cc
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12#include <iostream>
13#include <fstream>
14#include <string>
15#include <mutex>
16#include <map>
17
18#include <zypp-core/base/Logger.h>
19#include <zypp-core/base/LogControl.h>
20#include <zypp-core/base/ProfilingFormater.h>
21#include <zypp-core/base/PtrTypes.h>
22#include <zypp-core/base/String.h>
23#include <zypp-core/Date.h>
24#include <zypp-core/TriBool.h>
25#include <zypp-core/AutoDispose.h>
26
27#include <utility>
28#include <zypp-core/ng/io/Socket>
29#include <zypp-core/ng/io/SockAddr>
30#include <zypp-core/ng/base/EventLoop>
31#include <zypp-core/ng/base/EventDispatcher>
32#include <zypp-core/ng/base/Timer>
33#include <zypp-core/ng/base/private/linuxhelpers_p.h>
34#include <zypp-core/ng/thread/Wakeup>
35#include <zypp-core/ng/base/private/threaddata_p.h>
36#include <zypp-core/ng/base/SocketNotifier>
37
38#include <thread>
39#include <variant>
40#include <atomic>
41#include <csignal>
42
43extern "C"
44{
45#include <sys/types.h>
46#include <sys/stat.h>
47#include <fcntl.h>
48#include <unistd.h>
49#include <dirent.h>
50}
51
52using std::endl;
53
54std::once_flag flagReadEnvAutomatically;
55
56namespace zypp
57{
58 constexpr std::string_view ZYPP_MAIN_THREAD_NAME( "Zypp-main" );
59
60 template<class> inline constexpr bool always_false_v = false;
61
66 class SpinLock {
67 public:
68 void lock () {
69 // acquire lock
70 while ( _atomicLock.test_and_set())
71 // Reschedule the current thread while we wait. Maybe, when it is our next turn, the lock is free again.
72 std::this_thread::yield();
73 }
74
75 void unlock() {
76 _atomicLock.clear();
77 }
78
79 private:
80 // we use a lock-free atomic flag here, so this lock can be safely obtained in a signal handler as well
81 std::atomic_flag _atomicLock = ATOMIC_FLAG_INIT;
82 };
83
84 class LogThread
85 {
86
87 public:
88 LogThread(const LogThread &) = delete;
89 LogThread(LogThread &&) = delete;
90 LogThread &operator=(const LogThread &) = delete;
91 LogThread &operator=(LogThread &&) = delete;
92
93 ~LogThread() { stop(); }
94
95 static LogThread &instance () {
96 static LogThread t;
97 return t;
98 }
99
100 void setLineWriter ( zypp::shared_ptr<log::LineWriter> writer ) {
101 std::lock_guard lk( _lineWriterLock );
102 _lineWriter = std::move(writer);
103 }
104
105 zypp::shared_ptr<log::LineWriter> getLineWriter () {
106 std::lock_guard lk( _lineWriterLock );
107 auto lw = _lineWriter;
108 return lw;
109 }
110
111 void stop () {
112 _stopSignal.notify();
113 if ( _thread.get_id() != std::this_thread::get_id() )
114 _thread.join();
115 }
116
117 std::thread::id threadId () {
118 return _thread.get_id();
119 }
120
121 static std::string sockPath () {
122 static std::string path = zypp::str::Format("zypp-logsocket-%1%") % getpid();
123 return path;
124 }
125
126 private:
127
128 LogThread ()
129 {
130 // Name the thread that started the logger, assuming it's the main thread.
131 zyppng::ThreadData::current().setName(ZYPP_MAIN_THREAD_NAME);
132 _thread = std::thread( [this] () {
133 workerMain();
134 });
135 }
136
137 void workerMain () {
138
139 // force the kernel to pick another thread to handle signals
140 zyppng::blockAllSignalsForCurrentThread();
141
142 zyppng::ThreadData::current().setName("Zypp-Log");
143
144 auto ev = zyppng::EventLoop::create();
145 auto server = zyppng::Socket::create( AF_UNIX, SOCK_STREAM, 0 );
146 auto stopNotifyWatch = _stopSignal.makeNotifier( );
147
148 std::vector<zyppng::Socket::Ptr> clients;
149
150 // bind to a abstract unix domain socket address, which means we do not need to care about cleaning it up
151 server->bind( std::make_shared<zyppng::UnixSockAddr>( sockPath(), true ) );
152 server->listen();
153
154 // wait for incoming connections from other threads
155 server->connectFunc( &zyppng::Socket::sigIncomingConnection, [&](){
156
157 auto cl = server->accept();
158 if ( !cl ) return;
159 clients.push_back( cl );
160
161 // wait until data is available, we operate line by line so we only
162 // log a string once we encounter \n
163 cl->connectFunc( &zyppng::Socket::sigReadyRead, [ this, sock = cl.get() ](){
164 auto writer = getLineWriter();
165 if ( !writer ) return;
166 while ( sock->canReadLine() ) {
167 auto br = sock->readLine();
168 writer->writeOut( std::string( br.data(), br.size() - 1 ) );
169 }
170 }, *cl);
171
172 // once a client disconnects we remove it from the std::vector so that the socket is not leaked
173 cl->connectFunc( &zyppng::Socket::sigDisconnected, [&clients, sock = std::weak_ptr(cl)](){
174 auto lock = sock.lock();
175 if ( !lock )
176 return;
177
178 auto idx = std::find_if( clients.begin(), clients.end(), [lock]( const auto &s ){ return lock.get() == s.get(); } );
179 clients.erase( idx );
180 });
181
182 });
183
184 stopNotifyWatch->connectFunc( &zyppng::SocketNotifier::sigActivated, [&ev]( const auto &, auto ) {
185 ev->quit();
186 });
187
188 ev->run();
189
190 // make sure we have written everything
191 auto writer = getLineWriter();
192 if ( writer ) {
193 for ( auto &sock : clients ){
194 auto br = sock->readLine();
195 while ( !br.empty() ) {
196 if ( br.back () == '\n' )
197 writer->writeOut( std::string( br.data(), br.size() - 1 ) );
198 else
199 writer->writeOut( std::string( br.data(), br.size() ) );
200
201 br = sock->readLine();
202 }
203 }
204 }
205 }
206
207 private:
208 std::thread _thread;
209 zyppng::Wakeup _stopSignal;
210
211 // since the public API uses boost::shared_ptr (via the alias zypp::shared_ptr) we can not use the atomic
212 // functionalities provided in std.
213 // this lock type can be used safely in signals
214 SpinLock _lineWriterLock;
215 // boost shared_ptr has a lock free implementation of reference counting so it can be used from signal handlers as well
216 shared_ptr<log::LineWriter> _lineWriter{ nullptr };
217 };
218
219 class LogClient
220 {
221 public:
222 LogClient(){
223 // make sure the thread is running
224 LogThread::instance();
225 }
226
227 LogClient(const LogClient &) = delete;
228 LogClient(LogClient &&) = delete;
229 LogClient &operator=(const LogClient &) = delete;
230 LogClient &operator=(LogClient &&) = delete;
231
232 ~LogClient() { if (_sockFD >= 0) ::close(_sockFD); }
233
238 bool ensureConnection () {
239 if ( _sockFD >= 0 )
240 return true;
241
242 _sockFD = ::socket( AF_UNIX, SOCK_STREAM, 0 );
243 if ( _sockFD == -1 )
244 return false;
245
246 zyppng::UnixSockAddr addr( LogThread::sockPath(), true );
247 return zyppng::trySocketConnection( _sockFD, addr, 100 );
248 }
249
253 void pushMessage ( std::string msg ) {
254 if ( inPushMessage ) {
255 return;
256 }
257
258 // make sure we do not end up in a busy loop
259 zypp::AutoDispose<bool *> res( &inPushMessage, [](auto val){
260 *val = false;
261 });
262 inPushMessage = true;
263
264 // if we are in the same thread as the Log worker we can directly push our messages out, no need to use the socket
265 if ( std::this_thread::get_id() == LogThread::instance().threadId() ) {
266 auto writer = LogThread::instance().getLineWriter();
267 if ( writer )
268 writer->writeOut( msg );
269 return;
270 }
271
272 if(!ensureConnection())
273 return;
274
275 if ( msg.back() != '\n' )
276 msg.push_back('\n');
277
278 size_t written = 0;
279 while ( written < msg.size() ) {
280 const auto res = zyppng::eintrSafeCall( ::send, _sockFD, msg.data() + written, msg.size() - written, MSG_NOSIGNAL );
281 if ( res == -1 ) {
282 //assume broken socket
283 ::close( _sockFD );
284 _sockFD = -1;
285 return;
286 }
287 written += res;
288 }
289 }
290
291 private:
292 int _sockFD = -1;
293 bool inPushMessage = false;
294 };
295
296#ifndef ZYPP_NDEBUG
297 namespace debug
298 {
299 // Fg::Black: 30 Bg: 40 Attr::Normal: 22;27
300 // Fg::Red: 31 ... Attr::Bright: 1
301 // Fg::Green: 32 Attr::Reverse: 7
302 // Fg::Yellow: 33
303 // Fg::Blue: 34
304 // Fg::Magenta: 35
305 // Fg::Cyan: 36
306 // Fg::White: 37
307 // Fg::Default: 39
308 static constexpr std::string_view OO { "\033[0m" };
309 static constexpr std::string_view WH { "\033[37;40m" };
310 static constexpr std::string_view CY { "\033[36;40m" };
311 static constexpr std::string_view YE { "\033[33;1;40m" };
312 static constexpr std::string_view GR { "\033[32;40m" };
313 static constexpr std::string_view RE { "\033[31;1;40m" };
314 static constexpr std::string_view MA { "\033[35;40m" };
315
316 unsigned TraceLeave::_depth = 0;
317
318 std::string tracestr( char tag_r, unsigned depth_r, const std::string & msg_r, const char * file_r, const char * fnc_r, int line_r )
319 {
320 static str::Format fmt { "***%2d %s%c %s(%s):%d %s" };
321 fmt % depth_r %std::string(depth_r,'.') % tag_r % Pathname::basename(file_r) % fnc_r % line_r % msg_r;
322 return fmt;
323 }
324
325 TraceLeave::TraceLeave( const char * file_r, const char * fnc_r, int line_r, std::string msg_r )
326 : _file( file_r )
327 , _fnc( fnc_r )
328 , _line( line_r )
329 , _msg( std::move(msg_r) )
330 {
331 unsigned depth = _depth++;
332 const std::string & m { tracestr( '>',depth, _msg, _file,_fnc,_line ) };
333 Osd(L_USR("TRACE"),depth) << m << endl;
334 }
335
336 TraceLeave::~TraceLeave()
337 {
338 unsigned depth = --_depth;
339 const std::string & m { tracestr( '<',depth, _msg, _file,_fnc,_line ) };
340 Osd(L_USR("TRACE"),depth) << m << endl;
341 }
342
343 Osd::Osd( std::ostream & str, int i )
344 : _strout { std::cerr }
345 , _strlog { str }
346 { _strout << (i?WH:YE); }
347
348 Osd::~Osd()
349 { _strout << OO; }
350
351 Osd & Osd::operator<<( std::ostream& (*iomanip)( std::ostream& ) )
352 {
353 _strout << iomanip;
354 _strlog << iomanip;
355 return *this;
356 }
357}
358#endif // ZYPP_NDEBUG
359
361 namespace log
362 {
363
364 StdoutLineWriter::StdoutLineWriter()
365 : StreamLineWriter( std::cout )
366 {}
367
368 StderrLineWriter::StderrLineWriter()
369 : StreamLineWriter( std::cerr )
370 {}
371
372 FileLineWriter::FileLineWriter( const Pathname & file_r, mode_t mode_r )
373 {
374 if ( file_r == Pathname("-") )
375 {
376 _str = &std::cerr;
377 }
378 else
379 {
380 if ( mode_r )
381 {
382 // not filesystem::assert_file as filesystem:: functions log,
383 // and this FileWriter is not yet in place.
384 int fd = ::open( file_r.c_str(), O_CREAT|O_EXCL, mode_r );
385 if ( fd != -1 )
386 ::close( fd );
387 }
388 // set unbuffered write
389 std::ofstream * fstr = 0;
390 _outs.reset( (fstr = new std::ofstream( file_r.asString().c_str(), std::ios_base::app )) );
391 fstr->rdbuf()->pubsetbuf(0,0);
392 _str = &(*fstr);
393 }
394 }
395
397 } // namespace log
398
399
401 namespace base
402 {
404 namespace logger
405 {
406
407 inline void putStream( const std::string & group_r, LogLevel level_r,
408 const char * file_r, const char * func_r, int line_r,
409 const std::string & buffer_r );
410
412 //
413 // CLASS NAME : Loglinebuf
414 //
415 class Loglinebuf : public std::streambuf {
416
417 public:
419 Loglinebuf( std::string group_r, LogLevel level_r )
420 : _group(std::move( group_r ))
421 , _level( level_r )
422 , _file( "" )
423 , _func( "" )
424 , _line( -1 )
425 {}
426
427 Loglinebuf(const Loglinebuf &) = default;
428 Loglinebuf(Loglinebuf &&) = default;
429 Loglinebuf &operator=(const Loglinebuf &) = default;
430 Loglinebuf &operator=(Loglinebuf &&) = default;
431
433 ~Loglinebuf() override
434 {
435 if ( !_buffer.empty() )
436 writeout( "\n", 1 );
437 }
438
440 void tagSet( const char * fil_r, const char * fnc_r, int lne_r )
441 {
442 _file = fil_r;
443 _func = fnc_r;
444 _line = lne_r;
445 }
446
447 private:
449 std::streamsize xsputn( const char * s, std::streamsize n ) override
450 { return writeout( s, n ); }
451
452 int overflow( int ch = EOF ) override
453 {
454 if ( ch != EOF )
455 {
456 char tmp = ch;
457 writeout( &tmp, 1 );
458 }
459 return 0;
460 }
461
462 virtual int writeout( const char* s, std::streamsize n )
463 {
464 //logger::putStream( _group, _level, _file, _func, _line, _buffer );
465 //return n;
466 if ( s && n )
467 {
468 const char * c = s;
469 for ( int i = 0; i < n; ++i, ++c )
470 {
471 if ( *c == '\n' ) {
472 _buffer += std::string( s, c-s );
473 logger::putStream( _group, _level, _file, _func, _line, _buffer );
474 _buffer = std::string();
475 s = c+1;
476 }
477 }
478 if ( s < c )
479 {
480 _buffer += std::string( s, c-s );
481 }
482 }
483 return n;
484 }
485
486 private:
487 std::string _group;
488 LogLevel _level;
489 const char * _file;
490 const char * _func;
491 int _line;
492 std::string _buffer;
493 };
494
496
498 //
499 // CLASS NAME : Loglinestream
500 //
501 class Loglinestream {
502
503 public:
505 Loglinestream( const std::string & group_r, LogLevel level_r )
506 : _mybuf( group_r, level_r )
507 , _mystream( &_mybuf )
508 {}
509
510 Loglinestream(const Loglinestream &) = delete;
511 Loglinestream(Loglinestream &&) = delete;
512 Loglinestream &operator=(const Loglinestream &) = delete;
513 Loglinestream &operator=(Loglinestream &&) = delete;
514
516 ~Loglinestream()
517 { _mystream.flush(); }
518
519 public:
521 std::ostream & getStream( const char * fil_r, const char * fnc_r, int lne_r )
522 {
523 _mybuf.tagSet( fil_r, fnc_r, lne_r );
524 return _mystream;
525 }
526
527 private:
528 Loglinebuf _mybuf;
529 std::ostream _mystream;
530 };
531
532
533 struct LogControlImpl;
534
535 /*
536 * Ugly hack to prevent the use of LogControlImpl when libzypp is shutting down.
537 * Due to the C++ standard, thread_local static instances are cleaned up before the first global static
538 * destructor is called. So all classes that use logging after that point in time would crash the
539 * application because it is accessing a variable that has already been destroyed.
540 */
541 int &logControlValidFlag() {
542 // We are using a POD flag that does not have a destructor,
543 // to flag if the thread_local destructors were already executed.
544 // Since TLS data is stored in a segment that is available until the thread ceases to exist it should still be readable
545 // after thread_local c++ destructors were already executed. Or so I hope.
546 static thread_local int logControlValid = 0;
547 return logControlValid;
548 }
549
551 //
552 // CLASS NAME : LogControlImpl
553 //
563 struct LogControlImpl
564 {
565 public:
566 bool isExcessive() const { return _excessive; }
567
568 void excessive( bool onOff_r )
569 { _excessive = onOff_r; }
570
571
573 bool hideThreadName() const
574 {
575 if ( indeterminate(_hideThreadName) )
576 _hideThreadName = ( zyppng::ThreadData::current().name() == ZYPP_MAIN_THREAD_NAME );
577 return bool(_hideThreadName);
578 }
579
580 void hideThreadName( bool onOff_r )
581 { _hideThreadName = onOff_r; }
582
584 static bool instanceHideThreadName()
585 {
586 auto impl = LogControlImpl::instance();
587 return impl ? impl->hideThreadName() : false;
588 }
589
590 static void instanceHideThreadName( bool onOff_r )
591 {
592 auto impl = LogControlImpl::instance();
593 if ( impl ) impl->hideThreadName( onOff_r );
594 }
595
597 static bool instanceLogToPPID( )
598 {
599 auto impl = LogControlImpl::instance();
600 return impl ? impl->_logToPPIDMode : false;
601 }
602
604 static void instanceSetLogToPPID( bool onOff_r )
605 {
606 auto impl = LogControlImpl::instance();
607 if ( impl )
608 impl->_logToPPIDMode = onOff_r;
609 }
610
612 void setLineWriter( const shared_ptr<LogControl::LineWriter> & writer_r )
613 { LogThread::instance().setLineWriter( writer_r ); }
614
615 shared_ptr<LogControl::LineWriter> getLineWriter() const
616 { return LogThread::instance().getLineWriter(); }
617
619 void setLineFormater( const shared_ptr<LogControl::LineFormater> & format_r )
620 {
621 if ( format_r )
622 _lineFormater = format_r;
623 else
624 _lineFormater.reset( new LogControl::LineFormater );
625 }
626
627 void logfile( const Pathname & logfile_r, mode_t mode_r = 0640 )
628 {
629 if ( logfile_r.empty() )
630 setLineWriter( shared_ptr<LogControl::LineWriter>() );
631 else if ( logfile_r == Pathname( "-" ) )
632 setLineWriter( shared_ptr<LogControl::LineWriter>(new log::StderrLineWriter) );
633 else
634 setLineWriter( shared_ptr<LogControl::LineWriter>(new log::FileLineWriter(logfile_r, mode_r)) );
635 }
636
637 private:
638 LogClient _logClient;
639 std::ostream _no_stream;
640 bool _excessive;
641 bool _logToPPIDMode = false;
642 mutable TriBool _hideThreadName = indeterminate;
643
644 shared_ptr<LogControl::LineFormater> _lineFormater;
645
646 public:
648 std::ostream & getStream( const std::string & group_r,
649 LogLevel level_r,
650 const char * file_r,
651 const char * func_r,
652 const int line_r )
653 {
654 if ( ! getLineWriter() )
655 return _no_stream;
656 if ( level_r == E_XXX && !_excessive )
657 return _no_stream;
658
659 if ( !_streamtable[group_r][level_r] )
660 {
661 _streamtable[group_r][level_r].reset( new Loglinestream( group_r, level_r ) );
662 }
663 std::ostream & ret( _streamtable[group_r][level_r]->getStream( file_r, func_r, line_r ) );
664 if ( !ret )
665 {
666 ret.clear();
667 ret << "---<RESET LOGSTREAM FROM FAILED STATE]" << endl;
668 }
669 return ret;
670 }
671
672 void putRawLine ( std::string &&line ) {
673 _logClient.pushMessage( std::move(line) );
674 }
675
677 void putStream( const std::string & group_r,
678 LogLevel level_r,
679 const char * file_r,
680 const char * func_r,
681 int line_r,
682 const std::string & message_r )
683 {
684 _logClient.pushMessage( _lineFormater->format( group_r, level_r,
685 file_r, func_r, line_r,
686 message_r ) );
687 }
688
689 private:
690 using StreamPtr = shared_ptr<Loglinestream>;
691 using StreamSet = std::map<LogLevel, StreamPtr>;
692 using StreamTable = std::map<std::string, StreamSet>;
694 StreamTable _streamtable;
695 zyppng::Socket::Ptr _sock;
696
697 private:
698
699 void readEnvVars () {
700 if ( getenv("ZYPP_LOGFILE") )
701 logfile( getenv("ZYPP_LOGFILE") );
702
703 if ( getenv("ZYPP_PROFILING") )
704 {
705 shared_ptr<LogControl::LineFormater> formater(new ProfilingFormater);
706 setLineFormater(formater);
707 }
708 }
709
712 LogControlImpl()
713 : _no_stream( NULL )
714 , _excessive( getenv("ZYPP_FULLLOG") )
715 , _lineFormater( new LogControl::LineFormater )
716 {
717 logControlValidFlag() = 1;
718 std::call_once( flagReadEnvAutomatically, &LogControlImpl::readEnvVars, this);
719
720 // make sure the LogControl is invalidated when we fork
721 pthread_atfork( nullptr, nullptr, &LogControl::notifyFork );
722 }
723
724 public:
725
726 LogControlImpl(const LogControlImpl &) = delete;
727 LogControlImpl(LogControlImpl &&) = delete;
728 LogControlImpl &operator=(const LogControlImpl &) = delete;
729 LogControlImpl &operator=(LogControlImpl &&) = delete;
730
731 ~LogControlImpl()
732 {
733 logControlValidFlag() = 0;
734 }
735
742 static LogControlImpl *instance();
743 };
744
745
746 // 'THE' LogControlImpl singleton
747 inline LogControlImpl *LogControlImpl::instance()
748 {
749 thread_local static LogControlImpl _instance;
750 if ( logControlValidFlag() > 0 )
751 return &_instance;
752 return nullptr;
753 }
754
756
758 inline std::ostream & operator<<( std::ostream & str, const LogControlImpl & )
759 {
760 return str << "LogControlImpl";
761 }
762
764 //
765 // Access from logger::
766 //
768
769 std::ostream & getStream( const char * group_r,
770 LogLevel level_r,
771 const char * file_r,
772 const char * func_r,
773 const int line_r )
774 {
775 static std::ostream nstream(NULL);
776 auto control = LogControlImpl::instance();
777 if ( !control || !group_r || strlen(group_r ) == 0 ) {
778 return nstream;
779 }
780
781
782
783 return control->getStream( group_r,
784 level_r,
785 file_r,
786 func_r,
787 line_r );
788 }
789
791 inline void putStream( const std::string & group_r, LogLevel level_r,
792 const char * file_r, const char * func_r, int line_r,
793 const std::string & buffer_r )
794 {
795 auto control = LogControlImpl::instance();
796 if ( !control )
797 return;
798
799 control->putStream( group_r, level_r,
800 file_r, func_r, line_r,
801 buffer_r );
802 }
803
804 bool isExcessive()
805 {
806 auto impl = LogControlImpl::instance();
807 if ( !impl )
808 return false;
809 return impl->isExcessive();
810 }
811
813 } // namespace logger
814
815
816 using logger::LogControlImpl;
817
819 // LineFormater
821 std::string LogControl::LineFormater::format( const std::string & group_r,
822 logger::LogLevel level_r,
823 const char * file_r,
824 const char * func_r,
825 int line_r,
826 const std::string & message_r )
827 {
828 static char hostname[1024];
829 static char nohostname[] = "unknown";
830 std::string now( Date::now().form( "%Y-%m-%d %H:%M:%S" ) );
831 std::string ret;
832
833 const bool logToPPID = LogControlImpl::instanceLogToPPID();
834 if ( !logToPPID && LogControlImpl::instanceHideThreadName() )
835 ret = str::form( "%s <%d> %s(%d) [%s] %s(%s):%d %s",
836 now.c_str(), level_r,
837 ( gethostname( hostname, 1024 ) ? nohostname : hostname ),
838 getpid(),
839 group_r.c_str(),
840 file_r, func_r, line_r,
841 message_r.c_str() );
842 else
843 ret = str::form( "%s <%d> %s(%d) [%s] %s(%s):%d {T:%s} %s",
844 now.c_str(), level_r,
845 ( gethostname( hostname, 1024 ) ? nohostname : hostname ),
846 logToPPID ? getppid() : getpid(),
847 group_r.c_str(),
848 file_r, func_r, line_r,
849 zyppng::ThreadData::current().name().c_str(),
850 message_r.c_str() );
851 return ret;
852 }
853
854 std::string LogControl::JournalLineFormater::format( const std::string & group_r,
855 logger::LogLevel level_r,
856 const char * file_r,
857 const char * func_r,
858 int line_r,
859 const std::string & message_r )
860 {
861 std::string ret;
862 if ( not LogControlImpl::instanceLogToPPID() && LogControlImpl::instanceHideThreadName() )
863 ret = str::form( "<%d> [%s] %s(%s):%d %s",
864 level_r, group_r.c_str(),
865 file_r, func_r, line_r,
866 message_r.c_str() );
867 else
868 ret = str::form( "<%d> [%s] %s(%s):%d {T:%s} %s",
869 level_r, group_r.c_str(),
870 file_r, func_r, line_r,
871 zyppng::ThreadData::current().name().c_str(),
872 message_r.c_str() );
873 return ret;
874 }
875
876 //
877 // CLASS NAME : LogControl
878 // Forward to LogControlImpl singleton.
879 //
881
882
883 void LogControl::logfile( const Pathname & logfile_r )
884 {
885 auto impl = LogControlImpl::instance();
886 if ( !impl )
887 return;
888
889 impl->logfile( logfile_r );
890 }
891
892 void LogControl::logfile( const Pathname & logfile_r, mode_t mode_r )
893 {
894 auto impl = LogControlImpl::instance();
895 if ( !impl )
896 return;
897
898 impl->logfile( logfile_r, mode_r );
899 }
900
901 shared_ptr<LogControl::LineWriter> LogControl::getLineWriter() const
902 {
903 auto impl = LogControlImpl::instance();
904 if ( !impl )
905 return nullptr;
906
907 return impl->getLineWriter();
908 }
909
910 void LogControl::setLineWriter( const shared_ptr<LineWriter> & writer_r )
911 {
912 auto impl = LogControlImpl::instance();
913 if ( !impl )
914 return;
915 impl->setLineWriter( writer_r );
916 }
917
918 void LogControl::setLineFormater( const shared_ptr<LineFormater> & formater_r )
919 {
920 auto impl = LogControlImpl::instance();
921 if ( !impl )
922 return;
923 impl->setLineFormater( formater_r );
924 }
925
926 void LogControl::enableLogForwardingMode(bool enable)
927 {
928 LogControlImpl::instanceSetLogToPPID ( enable );
929 }
930
931 void LogControl::logNothing()
932 {
933 auto impl = LogControlImpl::instance();
934 if ( !impl )
935 return;
936 impl->setLineWriter( shared_ptr<LineWriter>() );
937 }
938
939 void LogControl::logToStdErr()
940 {
941 auto impl = LogControlImpl::instance();
942 if ( !impl )
943 return;
944 impl->setLineWriter( shared_ptr<LineWriter>( new log::StderrLineWriter ) );
945 }
946
947 void base::LogControl::emergencyShutdown()
948 {
949 LogThread::instance().stop();
950 }
951
952 void LogControl::notifyFork()
953 {
954 logger::logControlValidFlag () = 0;
955 }
956
957 void LogControl::logRawLine ( std::string &&line )
958 {
959 LogControlImpl::instance ()->putRawLine ( std::move(line) );
960 }
961
963 //
964 // LogControl::TmpExcessive
965 //
967 LogControl::TmpExcessive::TmpExcessive()
968 {
969 auto impl = LogControlImpl::instance();
970 if ( !impl )
971 return;
972 impl->excessive( true );
973 }
974 LogControl::TmpExcessive::~TmpExcessive()
975 {
976 auto impl = LogControlImpl::instance();
977 if ( !impl )
978 return;
979 impl->excessive( false );
980 }
981
982 /******************************************************************
983 **
984 ** FUNCTION NAME : operator<<
985 ** FUNCTION TYPE : std::ostream &
986 */
987 std::ostream & operator<<( std::ostream & str, const LogControl & )
988 {
989 auto impl = LogControlImpl::instance();
990 if ( !impl )
991 return str;
992 return str << *impl;
993 }
994
996 } // namespace base
999} // namespace zypp
AutoDispose.h
Date.h
flagReadEnvAutomatically
std::once_flag flagReadEnvAutomatically
Definition LogControl.cc:54
LogControl.h
Logger.h
L_USR
#define L_USR(GROUP)
Definition Logger.h:114
ProfilingFormater.h
PtrTypes.h
String.h
TriBool.h
bool
shared_ptr
zypp::AutoDispose
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
Definition AutoDispose.h:95
zypp::Date::now
static Date now()
Return the current time.
Definition Date.h:78
zypp::LogClient
Definition LogControl.cc:220
zypp::LogClient::inPushMessage
bool inPushMessage
Definition LogControl.cc:293
zypp::LogClient::_sockFD
int _sockFD
Definition LogControl.cc:292
zypp::LogClient::ensureConnection
bool ensureConnection()
Definition LogControl.cc:238
zypp::LogClient::LogClient
LogClient(LogClient &&)=delete
zypp::LogClient::LogClient
LogClient(const LogClient &)=delete
zypp::LogClient::operator=
LogClient & operator=(const LogClient &)=delete
zypp::LogClient::~LogClient
~LogClient()
Definition LogControl.cc:232
zypp::LogClient::LogClient
LogClient()
Definition LogControl.cc:222
zypp::LogClient::operator=
LogClient & operator=(LogClient &&)=delete
zypp::LogClient::pushMessage
void pushMessage(std::string msg)
Definition LogControl.cc:253
zypp::LogThread::_lineWriter
shared_ptr< log::LineWriter > _lineWriter
Definition LogControl.cc:216
zypp::LogThread::stop
void stop()
Definition LogControl.cc:111
zypp::LogThread::_thread
std::thread _thread
Definition LogControl.cc:208
zypp::LogThread::operator=
LogThread & operator=(const LogThread &)=delete
zypp::LogThread::getLineWriter
zypp::shared_ptr< log::LineWriter > getLineWriter()
Definition LogControl.cc:105
zypp::LogThread::_stopSignal
zyppng::Wakeup _stopSignal
Definition LogControl.cc:209
zypp::LogThread::LogThread
LogThread(const LogThread &)=delete
zypp::LogThread::workerMain
void workerMain()
Definition LogControl.cc:137
zypp::LogThread::threadId
std::thread::id threadId()
Definition LogControl.cc:117
zypp::LogThread::LogThread
LogThread(LogThread &&)=delete
zypp::LogThread::operator=
LogThread & operator=(LogThread &&)=delete
zypp::LogThread::_lineWriterLock
SpinLock _lineWriterLock
Definition LogControl.cc:214
zypp::LogThread::LogThread
LogThread()
Definition LogControl.cc:128
zypp::LogThread::setLineWriter
void setLineWriter(zypp::shared_ptr< log::LineWriter > writer)
Definition LogControl.cc:100
zypp::LogThread::instance
static LogThread & instance()
Definition LogControl.cc:95
zypp::LogThread::sockPath
static std::string sockPath()
Definition LogControl.cc:121
zypp::LogThread::~LogThread
~LogThread()
Definition LogControl.cc:93
zypp::Pathname::basename
std::string basename() const
Return the last component of this path.
Definition Pathname.h:137
zypp::SpinLock
Definition LogControl.cc:66
zypp::SpinLock::_atomicLock
std::atomic_flag _atomicLock
Definition LogControl.cc:81
zypp::SpinLock::lock
void lock()
Definition LogControl.cc:68
zypp::SpinLock::unlock
void unlock()
Definition LogControl.cc:75
zypp::base::LogControl
Maintain logfile related options.
Definition LogControl.h:97
zypp::base::LogControl::operator<<
friend std::ostream & operator<<(std::ostream &str, const LogControl &obj)
Definition LogControl.cc:987
zypp::base::LogControl::LogControl
LogControl()
Default ctor: Singleton.
Definition LogControl.h:228
zypp::base::LogControl::getLineWriter
shared_ptr< LineWriter > getLineWriter() const
Get the current LineWriter.
Definition LogControl.cc:901
zypp::base::LogControl::setLineWriter
void setLineWriter(const shared_ptr< LineWriter > &writer_r)
Assign a LineWriter.
Definition LogControl.cc:910
zypp::base::LogControl::logToStdErr
void logToStdErr()
Log to std::err.
Definition LogControl.cc:939
zypp::base::LogControl::logRawLine
void logRawLine(std::string &&line)
will push a line to the logthread without formatting it
Definition LogControl.cc:957
zypp::base::LogControl::logNothing
void logNothing()
Turn off logging.
Definition LogControl.cc:931
zypp::base::LogControl::notifyFork
static void notifyFork()
This will completely disable logging.
Definition LogControl.cc:952
zypp::base::LogControl::setLineFormater
void setLineFormater(const shared_ptr< LineFormater > &formater_r)
Assign a LineFormater.
Definition LogControl.cc:918
zypp::base::LogControl::enableLogForwardingMode
void enableLogForwardingMode(bool enable=true)
Definition LogControl.cc:926
zypp::base::LogControl::logfile
void logfile(const Pathname &logfile_r)
Set path for the logfile.
Definition LogControl.cc:883
zypp::base::LogControl::emergencyShutdown
void emergencyShutdown()
will cause the log thread to exit and flush all sockets
Definition LogControl.cc:947
zypp::base::logger::Loglinebuf
Definition LogControl.cc:415
zypp::base::logger::Loglinebuf::overflow
int overflow(int ch=EOF) override
Definition LogControl.cc:452
zypp::base::logger::Loglinebuf::xsputn
std::streamsize xsputn(const char *s, std::streamsize n) override
Definition LogControl.cc:449
zypp::base::logger::Loglinebuf::_buffer
std::string _buffer
Definition LogControl.cc:492
zypp::base::logger::Loglinebuf::_func
const char * _func
Definition LogControl.cc:490
zypp::base::logger::Loglinebuf::~Loglinebuf
~Loglinebuf() override
Definition LogControl.cc:433
zypp::base::logger::Loglinebuf::Loglinebuf
Loglinebuf(const Loglinebuf &)=default
zypp::base::logger::Loglinebuf::Loglinebuf
Loglinebuf(std::string group_r, LogLevel level_r)
Definition LogControl.cc:419
zypp::base::logger::Loglinebuf::Loglinebuf
Loglinebuf(Loglinebuf &&)=default
zypp::base::logger::Loglinebuf::_group
std::string _group
Definition LogControl.cc:487
zypp::base::logger::Loglinebuf::_level
LogLevel _level
Definition LogControl.cc:488
zypp::base::logger::Loglinebuf::operator=
Loglinebuf & operator=(const Loglinebuf &)=default
zypp::base::logger::Loglinebuf::_file
const char * _file
Definition LogControl.cc:489
zypp::base::logger::Loglinebuf::tagSet
void tagSet(const char *fil_r, const char *fnc_r, int lne_r)
Definition LogControl.cc:440
zypp::base::logger::Loglinebuf::writeout
virtual int writeout(const char *s, std::streamsize n)
Definition LogControl.cc:462
zypp::base::logger::Loglinebuf::_line
int _line
Definition LogControl.cc:491
zypp::base::logger::Loglinebuf::operator=
Loglinebuf & operator=(Loglinebuf &&)=default
zypp::base::logger::Loglinestream
Definition LogControl.cc:501
zypp::base::logger::Loglinestream::~Loglinestream
~Loglinestream()
Definition LogControl.cc:516
zypp::base::logger::Loglinestream::_mystream
std::ostream _mystream
Definition LogControl.cc:529
zypp::base::logger::Loglinestream::Loglinestream
Loglinestream(const std::string &group_r, LogLevel level_r)
Definition LogControl.cc:505
zypp::base::logger::Loglinestream::Loglinestream
Loglinestream(const Loglinestream &)=delete
zypp::base::logger::Loglinestream::operator=
Loglinestream & operator=(const Loglinestream &)=delete
zypp::base::logger::Loglinestream::getStream
std::ostream & getStream(const char *fil_r, const char *fnc_r, int lne_r)
Definition LogControl.cc:521
zypp::base::logger::Loglinestream::Loglinestream
Loglinestream(Loglinestream &&)=delete
zypp::base::logger::Loglinestream::_mybuf
Loglinebuf _mybuf
Definition LogControl.cc:528
zypp::base::logger::Loglinestream::operator=
Loglinestream & operator=(Loglinestream &&)=delete
zypp::filesystem::Pathname
Pathname.
Definition Pathname.h:48
zypp::filesystem::Pathname::c_str
const char * c_str() const
String representation.
Definition Pathname.h:113
zypp::filesystem::Pathname::asString
const std::string & asString() const
String representation.
Definition Pathname.h:94
zypp::filesystem::Pathname::empty
bool empty() const
Test for an empty path.
Definition Pathname.h:117
zyppng::EventLoop::create
static Ptr create()
Definition eventloop_glib.cc:24
zyppng::IODevice::sigReadyRead
SignalProxy< void()> sigReadyRead()
Definition iodevice.cc:368
zyppng::SocketNotifier::sigActivated
SignalProxy< void(const SocketNotifier &sock, int evTypes)> sigActivated()
Definition socketnotifier.cc:76
zyppng::Socket::create
static Ptr create(int domain, int type, int protocol)
Definition socket.cc:458
zyppng::Socket::sigDisconnected
SignalProxy< void()> sigDisconnected()
Definition socket.cc:882
zyppng::Socket::sigIncomingConnection
SignalProxy< void()> sigIncomingConnection()
Definition socket.cc:872
zyppng::Socket::Ptr
std::shared_ptr< Socket > Ptr
Definition socket.h:71
zyppng::UnixSockAddr
Definition sockaddr.h:36
zyppng::Wakeup
Definition wakeup.h:23
zypp::TriBool
boost::logic::tribool TriBool
3-state boolean logic (true, false and indeterminate).
Definition String.h:31
linuxhelpers_p.h
form
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition String.cc:39
std
Definition ansi.h:855
str
String related utilities and Regular expression matching.
zypp::base::logger
Definition LogControl.cc:405
zypp::base::logger::logControlValidFlag
int & logControlValidFlag()
Definition LogControl.cc:541
zypp::base::logger::putStream
void putStream(const std::string &group_r, LogLevel level_r, const char *file_r, const char *func_r, int line_r, const std::string &buffer_r)
That's what Loglinebuf calls.
Definition LogControl.cc:791
zypp::base::logger::LogLevel
LogLevel
Definition of log levels.
Definition Logger.h:156
zypp::base::logger::E_XXX
@ E_XXX
Excessive logging.
Definition Logger.h:157
zypp::base::logger::isExcessive
bool isExcessive()
Definition LogControl.cc:804
zypp::base::logger::getStream
std::ostream & getStream(const char *group_r, LogLevel level_r, const char *file_r, const char *func_r, const int line_r)
Return a log stream to write on.
Definition LogControl.cc:769
zypp::base
Definition Random.cc:7
zypp::debug
Definition Debug.h:31
zypp::debug::WH
static constexpr std::string_view WH
Definition LogControl.cc:309
zypp::debug::OO
static constexpr std::string_view OO
Definition LogControl.cc:308
zypp::debug::YE
static constexpr std::string_view YE
Definition LogControl.cc:311
zypp::debug::CY
static constexpr std::string_view CY
Definition LogControl.cc:310
zypp::debug::GR
static constexpr std::string_view GR
Definition LogControl.cc:312
zypp::debug::tracestr
std::string tracestr(char tag_r, unsigned depth_r, const std::string &msg_r, const char *file_r, const char *fnc_r, int line_r)
Definition LogControl.cc:318
zypp::debug::MA
static constexpr std::string_view MA
Definition LogControl.cc:314
zypp::debug::RE
static constexpr std::string_view RE
Definition LogControl.cc:313
zypp::iomanip
Definition LogTools.h:438
zypp::log
Definition LogControl.cc:362
zypp::str::form
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition String.cc:39
zypp
Easy-to use interface to the ZYPP dependency resolver.
Definition CodePitfalls.doc:2
zypp::always_false_v
constexpr bool always_false_v
Definition LogControl.cc:60
zypp::ZYPP_MAIN_THREAD_NAME
constexpr std::string_view ZYPP_MAIN_THREAD_NAME("Zypp-main")
zyppng::blockAllSignalsForCurrentThread
bool blockAllSignalsForCurrentThread()
Definition linuxhelpers.cc:15
zyppng::trySocketConnection
bool trySocketConnection(int &sockFD, const SockAddr &addr, uint64_t timeout)
Definition linuxhelpers.cc:34
zyppng::eintrSafeCall
auto eintrSafeCall(Fun &&function, Args &&... args)
Definition linuxhelpers_p.h:50
zypp::base::LogControlImpl::instance
static LogControlImpl * instance()
The LogControlImpl singleton.
Definition LogControl.cc:747
zypp::base::LogControlImpl::readEnvVars
void readEnvVars()
Definition LogControl.cc:699
zypp::base::LogControlImpl::instanceHideThreadName
static bool instanceHideThreadName()
Definition LogControl.cc:584
zypp::base::LogControlImpl::LogControlImpl
LogControlImpl()
Singleton ctor.
Definition LogControl.cc:712
zypp::base::LogControlImpl::instanceSetLogToPPID
static void instanceSetLogToPPID(bool onOff_r)
Definition LogControl.cc:604
zypp::base::LogControlImpl::instanceLogToPPID
static bool instanceLogToPPID()
Hint for formatter wether we forward all logs to a parents log.
Definition LogControl.cc:597
zypp::base::LogControl::JournalLineFormater::format
std::string format(const std::string &, logger::LogLevel, const char *, const char *, int, const std::string &) override
Definition LogControl.cc:854
zypp::base::LogControl::LineFormater
If you want to format loglines by yourself, derive from this, and overload format.
Definition LogControl.h:115
zypp::base::LogControl::LineFormater::format
virtual std::string format(const std::string &, logger::LogLevel, const char *, const char *, int, const std::string &)
Definition LogControl.cc:821
zypp::base::LogControl::TmpExcessive::~TmpExcessive
~TmpExcessive()
Definition LogControl.cc:974
zypp::base::LogControl::TmpExcessive::TmpExcessive
TmpExcessive()
Definition LogControl.cc:967
zypp::base::ProfilingFormater
Definition ProfilingFormater.h:27
zypp::base::logger::LogControlImpl
LogControl implementation (thread_local Singleton).
Definition LogControl.cc:564
zypp::base::logger::LogControlImpl::_excessive
bool _excessive
Definition LogControl.cc:640
zypp::base::logger::LogControlImpl::putRawLine
void putRawLine(std::string &&line)
Definition LogControl.cc:672
zypp::base::logger::LogControlImpl::setLineWriter
void setLineWriter(const shared_ptr< LogControl::LineWriter > &writer_r)
NULL _lineWriter indicates no loggin.
Definition LogControl.cc:612
zypp::base::logger::LogControlImpl::instance
static LogControlImpl * instance()
The LogControlImpl singleton.
Definition LogControl.cc:747
zypp::base::logger::LogControlImpl::readEnvVars
void readEnvVars()
Definition LogControl.cc:699
zypp::base::logger::LogControlImpl::instanceHideThreadName
static bool instanceHideThreadName()
Definition LogControl.cc:584
zypp::base::logger::LogControlImpl::~LogControlImpl
~LogControlImpl()
Definition LogControl.cc:731
zypp::base::logger::LogControlImpl::LogControlImpl
LogControlImpl(LogControlImpl &&)=delete
zypp::base::logger::LogControlImpl::operator=
LogControlImpl & operator=(const LogControlImpl &)=delete
zypp::base::logger::LogControlImpl::operator<<
std::ostream & operator<<(std::ostream &str, const LogControlImpl &)
Stream output.
Definition LogControl.cc:758
zypp::base::logger::LogControlImpl::LogControlImpl
LogControlImpl()
Singleton ctor.
Definition LogControl.cc:712
zypp::base::logger::LogControlImpl::instanceHideThreadName
static void instanceHideThreadName(bool onOff_r)
Definition LogControl.cc:590
zypp::base::logger::LogControlImpl::isExcessive
bool isExcessive() const
Definition LogControl.cc:566
zypp::base::logger::LogControlImpl::instanceSetLogToPPID
static void instanceSetLogToPPID(bool onOff_r)
Definition LogControl.cc:604
zypp::base::logger::LogControlImpl::_streamtable
StreamTable _streamtable
one streambuffer per group and level
Definition LogControl.cc:694
zypp::base::logger::LogControlImpl::instanceLogToPPID
static bool instanceLogToPPID()
Hint for formatter wether we forward all logs to a parents log.
Definition LogControl.cc:597
zypp::base::logger::LogControlImpl::LogControlImpl
LogControlImpl(const LogControlImpl &)=delete
zypp::base::logger::LogControlImpl::excessive
void excessive(bool onOff_r)
Definition LogControl.cc:568
zypp::base::logger::LogControlImpl::StreamTable
std::map< std::string, StreamSet > StreamTable
Definition LogControl.cc:692
zypp::base::logger::LogControlImpl::_logToPPIDMode
bool _logToPPIDMode
Hint for formatter to use the PPID and always show the thread name.
Definition LogControl.cc:641
zypp::base::logger::LogControlImpl::setLineFormater
void setLineFormater(const shared_ptr< LogControl::LineFormater > &format_r)
Assert _lineFormater is not NULL.
Definition LogControl.cc:619
zypp::base::logger::LogControlImpl::getStream
std::ostream & getStream(const std::string &group_r, LogLevel level_r, const char *file_r, const char *func_r, const int line_r)
Provide the log stream to write (logger interface).
Definition LogControl.cc:648
zypp::base::logger::LogControlImpl::logfile
void logfile(const Pathname &logfile_r, mode_t mode_r=0640)
Definition LogControl.cc:627
zypp::base::logger::LogControlImpl::getLineWriter
shared_ptr< LogControl::LineWriter > getLineWriter() const
Definition LogControl.cc:615
zypp::base::logger::LogControlImpl::StreamSet
std::map< LogLevel, StreamPtr > StreamSet
Definition LogControl.cc:691
zypp::base::logger::LogControlImpl::_lineFormater
shared_ptr< LogControl::LineFormater > _lineFormater
Definition LogControl.cc:644
zypp::base::logger::LogControlImpl::operator=
LogControlImpl & operator=(LogControlImpl &&)=delete
zypp::base::logger::LogControlImpl::hideThreadName
bool hideThreadName() const
Hint for Formater whether to hide the thread name.
Definition LogControl.cc:573
zypp::base::logger::LogControlImpl::putStream
void putStream(const std::string &group_r, LogLevel level_r, const char *file_r, const char *func_r, int line_r, const std::string &message_r)
Format and write out a logline from Loglinebuf.
Definition LogControl.cc:677
zypp::base::logger::LogControlImpl::_no_stream
std::ostream _no_stream
Definition LogControl.cc:639
zypp::base::logger::LogControlImpl::hideThreadName
void hideThreadName(bool onOff_r)
Definition LogControl.cc:580
zypp::base::logger::LogControlImpl::_sock
zyppng::Socket::Ptr _sock
Definition LogControl.cc:695
zypp::base::logger::LogControlImpl::_logClient
LogClient _logClient
Definition LogControl.cc:638
zypp::base::logger::LogControlImpl::_hideThreadName
TriBool _hideThreadName
Hint for Formater whether to hide the thread name.
Definition LogControl.cc:642
zypp::base::logger::LogControlImpl::StreamPtr
shared_ptr< Loglinestream > StreamPtr
Definition LogControl.cc:690
zypp::debug::Osd
Definition Logger.h:47
zypp::debug::Osd::_strlog
std::ostream & _strlog
Definition Logger.h:63
zypp::debug::Osd::Osd
Osd(std::ostream &, int=0)
Definition LogControl.cc:343
zypp::debug::Osd::_strout
std::ostream & _strout
Definition Logger.h:62
zypp::debug::Osd::operator<<
Osd & operator<<(Tp &&val)
Definition Logger.h:52
zypp::debug::Osd::~Osd
~Osd()
Definition LogControl.cc:348
zypp::debug::TraceLeave::TraceLeave
TraceLeave(const TraceLeave &)=delete
zypp::debug::TraceLeave::~TraceLeave
~TraceLeave()
Definition LogControl.cc:336
zypp::debug::TraceLeave::_depth
static unsigned _depth
Definition Logger.h:36
zypp::debug::TraceLeave::_line
int _line
Definition Logger.h:39
zypp::debug::TraceLeave::_msg
std::string _msg
Definition Logger.h:40
zypp::debug::TraceLeave::_fnc
const char * _fnc
Definition Logger.h:38
zypp::debug::TraceLeave::_file
const char * _file
Definition Logger.h:37
zypp::log::FileLineWriter
LineWriter to file.
Definition LogControl.h:73
zypp::log::FileLineWriter::_outs
shared_ptr< void > _outs
Definition LogControl.h:76
zypp::log::FileLineWriter::FileLineWriter
FileLineWriter(const Pathname &file_r, mode_t mode_r=0)
Definition LogControl.cc:372
zypp::log::StderrLineWriter
LineWriter to stderr.
Definition LogControl.h:64
zypp::log::StderrLineWriter::StderrLineWriter
StderrLineWriter()
Definition LogControl.cc:368
zypp::log::StdoutLineWriter::StdoutLineWriter
StdoutLineWriter()
Definition LogControl.cc:364
zypp::log::StreamLineWriter::_str
std::ostream * _str
Definition LogControl.h:53
zypp::log::StreamLineWriter::StreamLineWriter
StreamLineWriter(std::ostream &str_r)
Definition LogControl.h:46
zypp::str::Format
Convenient building of std::string with boost::format.
Definition String.h:254
zyppng::ThreadData::setName
void setName(T &&name)
Definition threaddata_p.h:18
zyppng::ThreadData::current
static ZYPP_API ThreadData & current()
Definition threaddata.cc:16
zyppng::ThreadData::name
const std::string & name() const
Definition threaddata.cc:22
threaddata_p.h