Mercurial > hg > orthanc-wsi
annotate Resources/Orthanc/Core/Logging.cpp @ 98:ff0ef01c332c
shared copyright with osimis
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Wed, 04 Jan 2017 16:43:25 +0100 |
parents | 4b0e0f7c9957 |
children | a3e8ac8b7256 |
rev | line source |
---|---|
1 | 1 /** |
2 * Orthanc - A Lightweight, RESTful DICOM Store | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
98
ff0ef01c332c
shared copyright with osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
92
diff
changeset
|
5 * Copyright (C) 2017 Osimis, Belgium |
1 | 6 * |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU General Public License as | |
9 * published by the Free Software Foundation, either version 3 of the | |
10 * License, or (at your option) any later version. | |
11 * | |
12 * In addition, as a special exception, the copyright holders of this | |
13 * program give permission to link the code of its release with the | |
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
15 * that use the same license as the "OpenSSL" library), and distribute | |
16 * the linked executables. You must obey the GNU General Public License | |
17 * in all respects for all of the code used other than "OpenSSL". If you | |
18 * modify file(s) with this exception, you may extend this exception to | |
19 * your version of the file(s), but you are not obligated to do so. If | |
20 * you do not wish to do so, delete this exception statement from your | |
21 * version. If you delete this exception statement from all source files | |
22 * in the program, then also delete it here. | |
23 * | |
24 * This program is distributed in the hope that it will be useful, but | |
25 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
27 * General Public License for more details. | |
28 * | |
29 * You should have received a copy of the GNU General Public License | |
30 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
31 **/ | |
32 | |
33 | |
34 #include "PrecompiledHeaders.h" | |
35 #include "Logging.h" | |
36 | |
37 #if ORTHANC_ENABLE_LOGGING != 1 | |
38 | |
39 namespace Orthanc | |
40 { | |
41 namespace Logging | |
42 { | |
43 void Initialize() | |
44 { | |
45 } | |
46 | |
47 void Finalize() | |
48 { | |
49 } | |
50 | |
51 void Reset() | |
52 { | |
53 } | |
54 | |
55 void Flush() | |
56 { | |
57 } | |
58 | |
59 void EnableInfoLevel(bool enabled) | |
60 { | |
61 } | |
62 | |
63 void EnableTraceLevel(bool enabled) | |
64 { | |
65 } | |
66 | |
67 void SetTargetFile(const std::string& path) | |
68 { | |
69 } | |
70 | |
71 void SetTargetFolder(const std::string& path) | |
72 { | |
73 } | |
74 } | |
75 } | |
76 | |
92 | 77 |
78 #elif ORTHANC_ENABLE_LOGGING_PLUGIN == 1 | |
79 | |
80 /********************************************************* | |
81 * Logger compatible with the Orthanc plugin SDK | |
82 *********************************************************/ | |
83 | |
84 #include <boost/lexical_cast.hpp> | |
85 | |
86 namespace Orthanc | |
87 { | |
88 namespace Logging | |
89 { | |
90 static OrthancPluginContext* context_ = NULL; | |
91 | |
92 void Initialize(OrthancPluginContext* context) | |
93 { | |
94 context_ = context_; | |
95 } | |
96 | |
97 InternalLogger::InternalLogger(const char* level, | |
98 const char* file /* ignored */, | |
99 int line /* ignored */) : | |
100 level_(level) | |
101 { | |
102 } | |
103 | |
104 InternalLogger::~InternalLogger() | |
105 { | |
106 if (context_ != NULL) | |
107 { | |
108 if (level_ == "ERROR") | |
109 { | |
110 OrthancPluginLogError(context_, message_.c_str()); | |
111 } | |
112 else if (level_ == "WARNING") | |
113 { | |
114 OrthancPluginLogWarning(context_, message_.c_str()); | |
115 } | |
116 else if (level_ == "INFO") | |
117 { | |
118 OrthancPluginLogInfo(context_, message_.c_str()); | |
119 } | |
120 } | |
121 } | |
122 | |
123 InternalLogger& InternalLogger::operator<< (const std::string& message) | |
124 { | |
125 message_ += message; | |
126 return *this; | |
127 } | |
128 | |
129 InternalLogger& InternalLogger::operator<< (const char* message) | |
130 { | |
131 message_ += std::string(message); | |
132 return *this; | |
133 } | |
134 | |
135 InternalLogger& InternalLogger::operator<< (int message) | |
136 { | |
137 message_ += boost::lexical_cast<std::string>(message); | |
138 return *this; | |
139 } | |
140 } | |
141 } | |
142 | |
143 | |
144 #else /* ORTHANC_ENABLE_LOGGING_PLUGIN == 0 && ORTHANC_ENABLE_LOGGING == 1 */ | |
1 | 145 |
146 /********************************************************* | |
147 * Internal logger of Orthanc, that mimics some | |
148 * behavior from Google Log. | |
149 *********************************************************/ | |
150 | |
151 #include "OrthancException.h" | |
152 #include "Enumerations.h" | |
153 #include "Toolbox.h" | |
43 | 154 #include "SystemToolbox.h" |
1 | 155 |
156 #include <fstream> | |
157 #include <boost/filesystem.hpp> | |
158 #include <boost/thread.hpp> | |
159 | |
160 #if BOOST_HAS_DATE_TIME == 1 | |
161 # include <boost/date_time/posix_time/posix_time.hpp> | |
162 #else | |
163 # error Boost::date_time is required | |
164 #endif | |
165 | |
166 | |
167 namespace | |
168 { | |
169 struct LoggingContext | |
170 { | |
171 bool infoEnabled_; | |
172 bool traceEnabled_; | |
173 std::string targetFile_; | |
174 std::string targetFolder_; | |
175 | |
176 std::ostream* error_; | |
177 std::ostream* warning_; | |
178 std::ostream* info_; | |
179 | |
180 std::auto_ptr<std::ofstream> file_; | |
181 | |
182 LoggingContext() : | |
183 infoEnabled_(false), | |
184 traceEnabled_(false), | |
185 error_(&std::cerr), | |
186 warning_(&std::cerr), | |
187 info_(&std::cerr) | |
188 { | |
189 } | |
190 }; | |
191 } | |
192 | |
193 | |
194 | |
195 static std::auto_ptr<LoggingContext> loggingContext_; | |
196 static boost::mutex loggingMutex_; | |
197 | |
198 | |
199 | |
200 namespace Orthanc | |
201 { | |
202 namespace Logging | |
203 { | |
204 static void GetLogPath(boost::filesystem::path& log, | |
205 boost::filesystem::path& link, | |
206 const std::string& suffix, | |
207 const std::string& directory) | |
208 { | |
209 /** | |
210 From Google Log documentation: | |
211 | |
212 Unless otherwise specified, logs will be written to the filename | |
213 "<program name>.<hostname>.<user name>.log<suffix>.", | |
214 followed by the date, time, and pid (you can't prevent the date, | |
215 time, and pid from being in the filename). | |
216 | |
217 In this implementation : "hostname" and "username" are not used | |
218 **/ | |
219 | |
220 boost::posix_time::ptime now = boost::posix_time::second_clock::local_time(); | |
221 boost::filesystem::path root(directory); | |
43 | 222 boost::filesystem::path exe(SystemToolbox::GetPathToExecutable()); |
1 | 223 |
224 if (!boost::filesystem::exists(root) || | |
225 !boost::filesystem::is_directory(root)) | |
226 { | |
227 throw OrthancException(ErrorCode_CannotWriteFile); | |
228 } | |
229 | |
230 char date[64]; | |
231 sprintf(date, "%04d%02d%02d-%02d%02d%02d.%d", | |
232 static_cast<int>(now.date().year()), | |
233 now.date().month().as_number(), | |
234 now.date().day().as_number(), | |
235 now.time_of_day().hours(), | |
236 now.time_of_day().minutes(), | |
237 now.time_of_day().seconds(), | |
43 | 238 SystemToolbox::GetProcessId()); |
1 | 239 |
240 std::string programName = exe.filename().replace_extension("").string(); | |
241 | |
242 log = (root / (programName + ".log" + suffix + "." + std::string(date))); | |
243 link = (root / (programName + ".log" + suffix)); | |
244 } | |
245 | |
246 | |
247 static void PrepareLogFolder(std::auto_ptr<std::ofstream>& file, | |
248 const std::string& suffix, | |
249 const std::string& directory) | |
250 { | |
251 boost::filesystem::path log, link; | |
252 GetLogPath(log, link, suffix, directory); | |
253 | |
254 #if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) | |
255 boost::filesystem::remove(link); | |
256 boost::filesystem::create_symlink(log.filename(), link); | |
257 #endif | |
258 | |
259 file.reset(new std::ofstream(log.string().c_str())); | |
260 } | |
261 | |
262 | |
263 void Initialize() | |
264 { | |
265 boost::mutex::scoped_lock lock(loggingMutex_); | |
266 loggingContext_.reset(new LoggingContext); | |
267 } | |
268 | |
269 void Finalize() | |
270 { | |
271 boost::mutex::scoped_lock lock(loggingMutex_); | |
272 loggingContext_.reset(NULL); | |
273 } | |
274 | |
275 void Reset() | |
276 { | |
277 // Recover the old logging context | |
278 std::auto_ptr<LoggingContext> old; | |
279 | |
280 { | |
281 boost::mutex::scoped_lock lock(loggingMutex_); | |
282 if (loggingContext_.get() == NULL) | |
283 { | |
284 return; | |
285 } | |
286 else | |
287 { | |
288 old = loggingContext_; | |
289 | |
290 // Create a new logging context, | |
291 loggingContext_.reset(new LoggingContext); | |
292 } | |
293 } | |
294 | |
295 EnableInfoLevel(old->infoEnabled_); | |
296 EnableTraceLevel(old->traceEnabled_); | |
297 | |
298 if (!old->targetFolder_.empty()) | |
299 { | |
300 SetTargetFolder(old->targetFolder_); | |
301 } | |
302 else if (!old->targetFile_.empty()) | |
303 { | |
304 SetTargetFile(old->targetFile_); | |
305 } | |
306 } | |
307 | |
308 void EnableInfoLevel(bool enabled) | |
309 { | |
310 boost::mutex::scoped_lock lock(loggingMutex_); | |
311 assert(loggingContext_.get() != NULL); | |
312 | |
313 loggingContext_->infoEnabled_ = enabled; | |
314 | |
315 if (!enabled) | |
316 { | |
317 // Also disable the "TRACE" level when info-level debugging is disabled | |
318 loggingContext_->traceEnabled_ = false; | |
319 } | |
320 } | |
321 | |
322 void EnableTraceLevel(bool enabled) | |
323 { | |
324 boost::mutex::scoped_lock lock(loggingMutex_); | |
325 assert(loggingContext_.get() != NULL); | |
326 | |
327 loggingContext_->traceEnabled_ = enabled; | |
328 | |
329 if (enabled) | |
330 { | |
331 // Also enable the "INFO" level when trace-level debugging is enabled | |
332 loggingContext_->infoEnabled_ = true; | |
333 } | |
334 } | |
335 | |
336 | |
337 static void CheckFile(std::auto_ptr<std::ofstream>& f) | |
338 { | |
339 if (loggingContext_->file_.get() == NULL || | |
340 !loggingContext_->file_->is_open()) | |
341 { | |
342 throw OrthancException(ErrorCode_CannotWriteFile); | |
343 } | |
344 } | |
345 | |
346 void SetTargetFolder(const std::string& path) | |
347 { | |
348 boost::mutex::scoped_lock lock(loggingMutex_); | |
349 assert(loggingContext_.get() != NULL); | |
350 | |
351 PrepareLogFolder(loggingContext_->file_, "" /* no suffix */, path); | |
352 CheckFile(loggingContext_->file_); | |
353 | |
354 loggingContext_->targetFile_.clear(); | |
355 loggingContext_->targetFolder_ = path; | |
356 loggingContext_->warning_ = loggingContext_->file_.get(); | |
357 loggingContext_->error_ = loggingContext_->file_.get(); | |
358 loggingContext_->info_ = loggingContext_->file_.get(); | |
359 } | |
360 | |
361 | |
362 void SetTargetFile(const std::string& path) | |
363 { | |
364 boost::mutex::scoped_lock lock(loggingMutex_); | |
365 assert(loggingContext_.get() != NULL); | |
366 | |
367 loggingContext_->file_.reset(new std::ofstream(path.c_str(), std::fstream::app)); | |
368 CheckFile(loggingContext_->file_); | |
369 | |
370 loggingContext_->targetFile_ = path; | |
371 loggingContext_->targetFolder_.clear(); | |
372 loggingContext_->warning_ = loggingContext_->file_.get(); | |
373 loggingContext_->error_ = loggingContext_->file_.get(); | |
374 loggingContext_->info_ = loggingContext_->file_.get(); | |
375 } | |
376 | |
377 | |
378 InternalLogger::InternalLogger(const char* level, | |
379 const char* file, | |
380 int line) : | |
381 lock_(loggingMutex_), | |
382 stream_(&null_) // By default, logging to "/dev/null" is simulated | |
383 { | |
384 if (loggingContext_.get() == NULL) | |
385 { | |
386 fprintf(stderr, "ERROR: Trying to log a message after the finalization of the logging engine\n"); | |
387 return; | |
388 } | |
389 | |
39 | 390 try |
1 | 391 { |
39 | 392 LogLevel l = StringToLogLevel(level); |
393 | |
394 if ((l == LogLevel_Info && !loggingContext_->infoEnabled_) || | |
395 (l == LogLevel_Trace && !loggingContext_->traceEnabled_)) | |
396 { | |
397 // This logging level is disabled, directly exit and unlock | |
398 // the mutex to speed-up things. The stream is set to "/dev/null" | |
399 lock_.unlock(); | |
400 return; | |
401 } | |
1 | 402 |
39 | 403 // Compute the header of the line, temporary release the lock as |
404 // this is a time-consuming operation | |
405 lock_.unlock(); | |
406 std::string header; | |
1 | 407 |
39 | 408 { |
409 boost::filesystem::path path(file); | |
410 boost::posix_time::ptime now = boost::posix_time::microsec_clock::local_time(); | |
411 boost::posix_time::time_duration duration = now.time_of_day(); | |
1 | 412 |
39 | 413 /** |
414 From Google Log documentation: | |
1 | 415 |
39 | 416 "Log lines have this form: |
1 | 417 |
39 | 418 Lmmdd hh:mm:ss.uuuuuu threadid file:line] msg... |
1 | 419 |
39 | 420 where the fields are defined as follows: |
1 | 421 |
39 | 422 L A single character, representing the log level (eg 'I' for INFO) |
423 mm The month (zero padded; ie May is '05') | |
424 dd The day (zero padded) | |
425 hh:mm:ss.uuuuuu Time in hours, minutes and fractional seconds | |
426 threadid The space-padded thread ID as returned by GetTID() (this matches the PID on Linux) | |
427 file The file name | |
428 line The line number | |
429 msg The user-supplied message" | |
1 | 430 |
39 | 431 In this implementation, "threadid" is not printed. |
432 **/ | |
1 | 433 |
39 | 434 char date[32]; |
435 sprintf(date, "%c%02d%02d %02d:%02d:%02d.%06d ", | |
436 level[0], | |
437 now.date().month().as_number(), | |
438 now.date().day().as_number(), | |
439 duration.hours(), | |
440 duration.minutes(), | |
441 duration.seconds(), | |
442 static_cast<int>(duration.fractional_seconds())); | |
1 | 443 |
39 | 444 header = std::string(date) + path.filename().string() + ":" + boost::lexical_cast<std::string>(line) + "] "; |
445 } | |
1 | 446 |
447 | |
39 | 448 // The header is computed, we now re-lock the mutex to access |
449 // the stream objects. Pay attention that "loggingContext_", | |
450 // "infoEnabled_" or "traceEnabled_" might have changed while | |
451 // the mutex was unlocked. | |
452 lock_.lock(); | |
453 | |
454 if (loggingContext_.get() == NULL) | |
455 { | |
456 fprintf(stderr, "ERROR: Trying to log a message after the finalization of the logging engine\n"); | |
457 return; | |
458 } | |
1 | 459 |
39 | 460 switch (l) |
461 { | |
462 case LogLevel_Error: | |
463 stream_ = loggingContext_->error_; | |
464 break; | |
1 | 465 |
39 | 466 case LogLevel_Warning: |
467 stream_ = loggingContext_->warning_; | |
468 break; | |
1 | 469 |
39 | 470 case LogLevel_Info: |
471 if (loggingContext_->infoEnabled_) | |
472 { | |
473 stream_ = loggingContext_->info_; | |
474 } | |
475 | |
476 break; | |
1 | 477 |
39 | 478 case LogLevel_Trace: |
479 if (loggingContext_->traceEnabled_) | |
480 { | |
481 stream_ = loggingContext_->info_; | |
482 } | |
1 | 483 |
39 | 484 break; |
1 | 485 |
39 | 486 default: |
487 throw OrthancException(ErrorCode_InternalError); | |
488 } | |
1 | 489 |
39 | 490 if (stream_ == &null_) |
491 { | |
492 // The logging is disabled for this level. The stream is the | |
493 // "null_" member of this object, so we can release the global | |
494 // mutex. | |
495 lock_.unlock(); | |
496 } | |
1 | 497 |
39 | 498 (*stream_) << header; |
1 | 499 } |
39 | 500 catch (...) |
501 { | |
502 // Something is going really wrong, probably running out of | |
503 // memory. Fallback to a degraded mode. | |
504 stream_ = loggingContext_->error_; | |
505 (*stream_) << "E???? ??:??:??.?????? ] "; | |
506 } | |
1 | 507 } |
508 | |
509 | |
510 InternalLogger::~InternalLogger() | |
511 { | |
512 if (stream_ != &null_) | |
513 { | |
514 #if defined(_WIN32) | |
515 *stream_ << "\r\n"; | |
516 #else | |
517 *stream_ << "\n"; | |
518 #endif | |
519 | |
520 stream_->flush(); | |
521 } | |
522 } | |
523 | |
524 | |
525 void Flush() | |
526 { | |
527 boost::mutex::scoped_lock lock(loggingMutex_); | |
528 | |
529 if (loggingContext_.get() != NULL && | |
530 loggingContext_->file_.get() != NULL) | |
531 { | |
532 loggingContext_->file_->flush(); | |
533 } | |
534 } | |
535 } | |
536 } | |
537 | |
538 #endif // ORTHANC_ENABLE_LOGGING |