[795] | 1 | <?php |
---|
| 2 | /** |
---|
| 3 | * $Header: /repository/pear/Log/Log.php,v 1.74 2008/11/19 04:14:38 jon Exp $ |
---|
| 4 | * $Horde: horde/lib/Log.php,v 1.15 2000/06/29 23:39:45 jon Exp $ |
---|
| 5 | * |
---|
| 6 | * @version $Revision: 1.74 $ |
---|
| 7 | * @package Log |
---|
| 8 | */ |
---|
| 9 | |
---|
| 10 | define('PEAR_LOG_EMERG', 0); /* System is unusable */ |
---|
| 11 | define('PEAR_LOG_ALERT', 1); /* Immediate action required */ |
---|
| 12 | define('PEAR_LOG_CRIT', 2); /* Critical conditions */ |
---|
| 13 | define('PEAR_LOG_ERR', 3); /* Error conditions */ |
---|
| 14 | define('PEAR_LOG_WARNING', 4); /* Warning conditions */ |
---|
| 15 | define('PEAR_LOG_NOTICE', 5); /* Normal but significant */ |
---|
| 16 | define('PEAR_LOG_INFO', 6); /* Informational */ |
---|
| 17 | define('PEAR_LOG_DEBUG', 7); /* Debug-level messages */ |
---|
| 18 | |
---|
| 19 | define('PEAR_LOG_ALL', 0xffffffff); /* All messages */ |
---|
| 20 | define('PEAR_LOG_NONE', 0x00000000); /* No message */ |
---|
| 21 | |
---|
| 22 | /* Log types for PHP's native error_log() function. */ |
---|
| 23 | define('PEAR_LOG_TYPE_SYSTEM', 0); /* Use PHP's system logger */ |
---|
| 24 | define('PEAR_LOG_TYPE_MAIL', 1); /* Use PHP's mail() function */ |
---|
| 25 | define('PEAR_LOG_TYPE_DEBUG', 2); /* Use PHP's debugging connection */ |
---|
| 26 | define('PEAR_LOG_TYPE_FILE', 3); /* Append to a file */ |
---|
| 27 | |
---|
| 28 | /** |
---|
| 29 | * The Log:: class implements both an abstraction for various logging |
---|
| 30 | * mechanisms and the Subject end of a Subject-Observer pattern. |
---|
| 31 | * |
---|
| 32 | * @author Chuck Hagenbuch <chuck@horde.org> |
---|
| 33 | * @author Jon Parise <jon@php.net> |
---|
| 34 | * @since Horde 1.3 |
---|
| 35 | * @package Log |
---|
| 36 | */ |
---|
| 37 | class Log |
---|
| 38 | { |
---|
| 39 | /** |
---|
| 40 | * Indicates whether or not the log can been opened / connected. |
---|
| 41 | * |
---|
| 42 | * @var boolean |
---|
| 43 | * @access protected |
---|
| 44 | */ |
---|
| 45 | var $_opened = false; |
---|
| 46 | |
---|
| 47 | /** |
---|
| 48 | * Instance-specific unique identification number. |
---|
| 49 | * |
---|
| 50 | * @var integer |
---|
| 51 | * @access protected |
---|
| 52 | */ |
---|
| 53 | var $_id = 0; |
---|
| 54 | |
---|
| 55 | /** |
---|
| 56 | * The label that uniquely identifies this set of log messages. |
---|
| 57 | * |
---|
| 58 | * @var string |
---|
| 59 | * @access protected |
---|
| 60 | */ |
---|
| 61 | var $_ident = ''; |
---|
| 62 | |
---|
| 63 | /** |
---|
| 64 | * The default priority to use when logging an event. |
---|
| 65 | * |
---|
| 66 | * @var integer |
---|
| 67 | * @access protected |
---|
| 68 | */ |
---|
| 69 | var $_priority = PEAR_LOG_INFO; |
---|
| 70 | |
---|
| 71 | /** |
---|
| 72 | * The bitmask of allowed log levels. |
---|
| 73 | * |
---|
| 74 | * @var integer |
---|
| 75 | * @access protected |
---|
| 76 | */ |
---|
| 77 | var $_mask = PEAR_LOG_ALL; |
---|
| 78 | |
---|
| 79 | /** |
---|
| 80 | * Holds all Log_observer objects that wish to be notified of new messages. |
---|
| 81 | * |
---|
| 82 | * @var array |
---|
| 83 | * @access protected |
---|
| 84 | */ |
---|
| 85 | var $_listeners = array(); |
---|
| 86 | |
---|
| 87 | /** |
---|
| 88 | * Maps canonical format keys to position arguments for use in building |
---|
| 89 | * "line format" strings. |
---|
| 90 | * |
---|
| 91 | * @var array |
---|
| 92 | * @access protected |
---|
| 93 | */ |
---|
| 94 | var $_formatMap = array('%{timestamp}' => '%1$s', |
---|
| 95 | '%{ident}' => '%2$s', |
---|
| 96 | '%{priority}' => '%3$s', |
---|
| 97 | '%{message}' => '%4$s', |
---|
| 98 | '%{file}' => '%5$s', |
---|
| 99 | '%{line}' => '%6$s', |
---|
| 100 | '%{function}' => '%7$s', |
---|
| 101 | '%{class}' => '%8$s', |
---|
| 102 | '%\{' => '%%{'); |
---|
| 103 | |
---|
| 104 | /** |
---|
| 105 | * Utility function which wraps PHP's class_exists() function to ensure |
---|
| 106 | * consistent behavior between PHP versions 4 and 5. Autoloading behavior |
---|
| 107 | * is always disabled. |
---|
| 108 | * |
---|
| 109 | * @param string $class The name of the class whose existence should |
---|
| 110 | * be tested. |
---|
| 111 | * |
---|
| 112 | * @return bool True if the class exists. |
---|
| 113 | * |
---|
| 114 | * @access private |
---|
| 115 | * @since Log 1.9.13 |
---|
| 116 | */ |
---|
| 117 | function _classExists($class) |
---|
| 118 | { |
---|
| 119 | if (version_compare(PHP_VERSION, '5.0.0', 'ge')) { |
---|
| 120 | return class_exists($class, false); |
---|
| 121 | } |
---|
| 122 | |
---|
| 123 | return class_exists($class); |
---|
| 124 | } |
---|
| 125 | |
---|
| 126 | /** |
---|
| 127 | * Attempts to return a concrete Log instance of type $handler. |
---|
| 128 | * |
---|
| 129 | * @param string $handler The type of concrete Log subclass to return. |
---|
| 130 | * Attempt to dynamically include the code for |
---|
| 131 | * this subclass. Currently, valid values are |
---|
| 132 | * 'console', 'syslog', 'sql', 'file', and 'mcal'. |
---|
| 133 | * |
---|
| 134 | * @param string $name The name of the actually log file, table, or |
---|
| 135 | * other specific store to use. Defaults to an |
---|
| 136 | * empty string, with which the subclass will |
---|
| 137 | * attempt to do something intelligent. |
---|
| 138 | * |
---|
| 139 | * @param string $ident The identity reported to the log system. |
---|
| 140 | * |
---|
| 141 | * @param array $conf A hash containing any additional configuration |
---|
| 142 | * information that a subclass might need. |
---|
| 143 | * |
---|
| 144 | * @param int $level Log messages up to and including this level. |
---|
| 145 | * |
---|
| 146 | * @return object Log The newly created concrete Log instance, or |
---|
| 147 | * null on an error. |
---|
| 148 | * @access public |
---|
| 149 | * @since Log 1.0 |
---|
| 150 | */ |
---|
| 151 | function &factory($handler, $name = '', $ident = '', $conf = array(), |
---|
| 152 | $level = PEAR_LOG_DEBUG) |
---|
| 153 | { |
---|
| 154 | $handler = strtolower($handler); |
---|
| 155 | $class = 'Log_' . $handler; |
---|
| 156 | $classfile = 'Log/' . $handler . '.php'; |
---|
| 157 | |
---|
| 158 | /* |
---|
| 159 | * Attempt to include our version of the named class, but don't treat |
---|
| 160 | * a failure as fatal. The caller may have already included their own |
---|
| 161 | * version of the named class. |
---|
| 162 | */ |
---|
| 163 | if (!Log::_classExists($class)) { |
---|
| 164 | include_once $classfile; |
---|
| 165 | } |
---|
| 166 | |
---|
| 167 | /* If the class exists, return a new instance of it. */ |
---|
| 168 | if (Log::_classExists($class)) { |
---|
[3167] | 169 | $obj = new $class($name, $ident, $conf, $level); |
---|
[795] | 170 | return $obj; |
---|
| 171 | } |
---|
| 172 | |
---|
| 173 | $null = null; |
---|
| 174 | return $null; |
---|
| 175 | } |
---|
| 176 | |
---|
| 177 | /** |
---|
| 178 | * Attempts to return a reference to a concrete Log instance of type |
---|
| 179 | * $handler, only creating a new instance if no log instance with the same |
---|
| 180 | * parameters currently exists. |
---|
| 181 | * |
---|
| 182 | * You should use this if there are multiple places you might create a |
---|
| 183 | * logger, you don't want to create multiple loggers, and you don't want to |
---|
| 184 | * check for the existance of one each time. The singleton pattern does all |
---|
| 185 | * the checking work for you. |
---|
| 186 | * |
---|
| 187 | * <b>You MUST call this method with the $var = &Log::singleton() syntax. |
---|
| 188 | * Without the ampersand (&) in front of the method name, you will not get |
---|
| 189 | * a reference, you will get a copy.</b> |
---|
| 190 | * |
---|
| 191 | * @param string $handler The type of concrete Log subclass to return. |
---|
| 192 | * Attempt to dynamically include the code for |
---|
| 193 | * this subclass. Currently, valid values are |
---|
| 194 | * 'console', 'syslog', 'sql', 'file', and 'mcal'. |
---|
| 195 | * |
---|
| 196 | * @param string $name The name of the actually log file, table, or |
---|
| 197 | * other specific store to use. Defaults to an |
---|
| 198 | * empty string, with which the subclass will |
---|
| 199 | * attempt to do something intelligent. |
---|
| 200 | * |
---|
| 201 | * @param string $ident The identity reported to the log system. |
---|
| 202 | * |
---|
| 203 | * @param array $conf A hash containing any additional configuration |
---|
| 204 | * information that a subclass might need. |
---|
| 205 | * |
---|
| 206 | * @param int $level Log messages up to and including this level. |
---|
| 207 | * |
---|
| 208 | * @return object Log The newly created concrete Log instance, or |
---|
| 209 | * null on an error. |
---|
| 210 | * @access public |
---|
| 211 | * @since Log 1.0 |
---|
| 212 | */ |
---|
| 213 | function &singleton($handler, $name = '', $ident = '', $conf = array(), |
---|
| 214 | $level = PEAR_LOG_DEBUG) |
---|
| 215 | { |
---|
| 216 | static $instances; |
---|
| 217 | if (!isset($instances)) $instances = array(); |
---|
| 218 | |
---|
| 219 | $signature = serialize(array($handler, $name, $ident, $conf, $level)); |
---|
| 220 | if (!isset($instances[$signature])) { |
---|
| 221 | $instances[$signature] = &Log::factory($handler, $name, $ident, |
---|
| 222 | $conf, $level); |
---|
| 223 | } |
---|
| 224 | |
---|
| 225 | return $instances[$signature]; |
---|
| 226 | } |
---|
| 227 | |
---|
| 228 | /** |
---|
| 229 | * Abstract implementation of the open() method. |
---|
| 230 | * @since Log 1.0 |
---|
| 231 | */ |
---|
| 232 | function open() |
---|
| 233 | { |
---|
| 234 | return false; |
---|
| 235 | } |
---|
| 236 | |
---|
| 237 | /** |
---|
| 238 | * Abstract implementation of the close() method. |
---|
| 239 | * @since Log 1.0 |
---|
| 240 | */ |
---|
| 241 | function close() |
---|
| 242 | { |
---|
| 243 | return false; |
---|
| 244 | } |
---|
| 245 | |
---|
| 246 | /** |
---|
| 247 | * Abstract implementation of the flush() method. |
---|
| 248 | * @since Log 1.8.2 |
---|
| 249 | */ |
---|
| 250 | function flush() |
---|
| 251 | { |
---|
| 252 | return false; |
---|
| 253 | } |
---|
| 254 | |
---|
| 255 | /** |
---|
| 256 | * Abstract implementation of the log() method. |
---|
| 257 | * @since Log 1.0 |
---|
| 258 | */ |
---|
| 259 | function log($message, $priority = null) |
---|
| 260 | { |
---|
| 261 | return false; |
---|
| 262 | } |
---|
| 263 | |
---|
| 264 | /** |
---|
| 265 | * A convenience function for logging a emergency event. It will log a |
---|
| 266 | * message at the PEAR_LOG_EMERG log level. |
---|
| 267 | * |
---|
| 268 | * @param mixed $message String or object containing the message |
---|
| 269 | * to log. |
---|
| 270 | * |
---|
| 271 | * @return boolean True if the message was successfully logged. |
---|
| 272 | * |
---|
| 273 | * @access public |
---|
| 274 | * @since Log 1.7.0 |
---|
| 275 | */ |
---|
| 276 | function emerg($message) |
---|
| 277 | { |
---|
| 278 | return $this->log($message, PEAR_LOG_EMERG); |
---|
| 279 | } |
---|
| 280 | |
---|
| 281 | /** |
---|
| 282 | * A convenience function for logging an alert event. It will log a |
---|
| 283 | * message at the PEAR_LOG_ALERT log level. |
---|
| 284 | * |
---|
| 285 | * @param mixed $message String or object containing the message |
---|
| 286 | * to log. |
---|
| 287 | * |
---|
| 288 | * @return boolean True if the message was successfully logged. |
---|
| 289 | * |
---|
| 290 | * @access public |
---|
| 291 | * @since Log 1.7.0 |
---|
| 292 | */ |
---|
| 293 | function alert($message) |
---|
| 294 | { |
---|
| 295 | return $this->log($message, PEAR_LOG_ALERT); |
---|
| 296 | } |
---|
| 297 | |
---|
| 298 | /** |
---|
| 299 | * A convenience function for logging a critical event. It will log a |
---|
| 300 | * message at the PEAR_LOG_CRIT log level. |
---|
| 301 | * |
---|
| 302 | * @param mixed $message String or object containing the message |
---|
| 303 | * to log. |
---|
| 304 | * |
---|
| 305 | * @return boolean True if the message was successfully logged. |
---|
| 306 | * |
---|
| 307 | * @access public |
---|
| 308 | * @since Log 1.7.0 |
---|
| 309 | */ |
---|
| 310 | function crit($message) |
---|
| 311 | { |
---|
| 312 | return $this->log($message, PEAR_LOG_CRIT); |
---|
| 313 | } |
---|
| 314 | |
---|
| 315 | /** |
---|
| 316 | * A convenience function for logging a error event. It will log a |
---|
| 317 | * message at the PEAR_LOG_ERR log level. |
---|
| 318 | * |
---|
| 319 | * @param mixed $message String or object containing the message |
---|
| 320 | * to log. |
---|
| 321 | * |
---|
| 322 | * @return boolean True if the message was successfully logged. |
---|
| 323 | * |
---|
| 324 | * @access public |
---|
| 325 | * @since Log 1.7.0 |
---|
| 326 | */ |
---|
| 327 | function err($message) |
---|
| 328 | { |
---|
| 329 | return $this->log($message, PEAR_LOG_ERR); |
---|
| 330 | } |
---|
| 331 | |
---|
| 332 | /** |
---|
| 333 | * A convenience function for logging a warning event. It will log a |
---|
| 334 | * message at the PEAR_LOG_WARNING log level. |
---|
| 335 | * |
---|
| 336 | * @param mixed $message String or object containing the message |
---|
| 337 | * to log. |
---|
| 338 | * |
---|
| 339 | * @return boolean True if the message was successfully logged. |
---|
| 340 | * |
---|
| 341 | * @access public |
---|
| 342 | * @since Log 1.7.0 |
---|
| 343 | */ |
---|
| 344 | function warning($message) |
---|
| 345 | { |
---|
| 346 | return $this->log($message, PEAR_LOG_WARNING); |
---|
| 347 | } |
---|
| 348 | |
---|
| 349 | /** |
---|
| 350 | * A convenience function for logging a notice event. It will log a |
---|
| 351 | * message at the PEAR_LOG_NOTICE log level. |
---|
| 352 | * |
---|
| 353 | * @param mixed $message String or object containing the message |
---|
| 354 | * to log. |
---|
| 355 | * |
---|
| 356 | * @return boolean True if the message was successfully logged. |
---|
| 357 | * |
---|
| 358 | * @access public |
---|
| 359 | * @since Log 1.7.0 |
---|
| 360 | */ |
---|
| 361 | function notice($message) |
---|
| 362 | { |
---|
| 363 | return $this->log($message, PEAR_LOG_NOTICE); |
---|
| 364 | } |
---|
| 365 | |
---|
| 366 | /** |
---|
| 367 | * A convenience function for logging a information event. It will log a |
---|
| 368 | * message at the PEAR_LOG_INFO log level. |
---|
| 369 | * |
---|
| 370 | * @param mixed $message String or object containing the message |
---|
| 371 | * to log. |
---|
| 372 | * |
---|
| 373 | * @return boolean True if the message was successfully logged. |
---|
| 374 | * |
---|
| 375 | * @access public |
---|
| 376 | * @since Log 1.7.0 |
---|
| 377 | */ |
---|
| 378 | function info($message) |
---|
| 379 | { |
---|
| 380 | return $this->log($message, PEAR_LOG_INFO); |
---|
| 381 | } |
---|
| 382 | |
---|
| 383 | /** |
---|
| 384 | * A convenience function for logging a debug event. It will log a |
---|
| 385 | * message at the PEAR_LOG_DEBUG log level. |
---|
| 386 | * |
---|
| 387 | * @param mixed $message String or object containing the message |
---|
| 388 | * to log. |
---|
| 389 | * |
---|
| 390 | * @return boolean True if the message was successfully logged. |
---|
| 391 | * |
---|
| 392 | * @access public |
---|
| 393 | * @since Log 1.7.0 |
---|
| 394 | */ |
---|
| 395 | function debug($message) |
---|
| 396 | { |
---|
| 397 | return $this->log($message, PEAR_LOG_DEBUG); |
---|
| 398 | } |
---|
| 399 | |
---|
| 400 | /** |
---|
| 401 | * Returns the string representation of the message data. |
---|
| 402 | * |
---|
| 403 | * If $message is an object, _extractMessage() will attempt to extract |
---|
| 404 | * the message text using a known method (such as a PEAR_Error object's |
---|
| 405 | * getMessage() method). If a known method, cannot be found, the |
---|
| 406 | * serialized representation of the object will be returned. |
---|
| 407 | * |
---|
| 408 | * If the message data is already a string, it will be returned unchanged. |
---|
| 409 | * |
---|
| 410 | * @param mixed $message The original message data. This may be a |
---|
| 411 | * string or any object. |
---|
| 412 | * |
---|
| 413 | * @return string The string representation of the message. |
---|
| 414 | * |
---|
| 415 | * @access protected |
---|
| 416 | */ |
---|
| 417 | function _extractMessage($message) |
---|
| 418 | { |
---|
| 419 | /* |
---|
| 420 | * If we've been given an object, attempt to extract the message using |
---|
| 421 | * a known method. If we can't find such a method, default to the |
---|
| 422 | * "human-readable" version of the object. |
---|
| 423 | * |
---|
| 424 | * We also use the human-readable format for arrays. |
---|
| 425 | */ |
---|
| 426 | if (is_object($message)) { |
---|
| 427 | if (method_exists($message, 'getmessage')) { |
---|
| 428 | $message = $message->getMessage(); |
---|
| 429 | } else if (method_exists($message, 'tostring')) { |
---|
| 430 | $message = $message->toString(); |
---|
| 431 | } else if (method_exists($message, '__tostring')) { |
---|
| 432 | if (version_compare(PHP_VERSION, '5.0.0', 'ge')) { |
---|
| 433 | $message = (string)$message; |
---|
| 434 | } else { |
---|
| 435 | $message = $message->__toString(); |
---|
| 436 | } |
---|
| 437 | } else { |
---|
| 438 | $message = var_export($message, true); |
---|
| 439 | } |
---|
| 440 | } else if (is_array($message)) { |
---|
| 441 | if (isset($message['message'])) { |
---|
| 442 | if (is_scalar($message['message'])) { |
---|
| 443 | $message = $message['message']; |
---|
| 444 | } else { |
---|
| 445 | $message = var_export($message['message'], true); |
---|
| 446 | } |
---|
| 447 | } else { |
---|
| 448 | $message = var_export($message, true); |
---|
| 449 | } |
---|
| 450 | } else if (is_bool($message) || $message === NULL) { |
---|
| 451 | $message = var_export($message, true); |
---|
| 452 | } |
---|
| 453 | |
---|
| 454 | /* Otherwise, we assume the message is a string. */ |
---|
| 455 | return $message; |
---|
| 456 | } |
---|
| 457 | |
---|
| 458 | /** |
---|
| 459 | * Using debug_backtrace(), returns the file, line, and enclosing function |
---|
| 460 | * name of the source code context from which log() was invoked. |
---|
| 461 | * |
---|
| 462 | * @param int $depth The initial number of frames we should step |
---|
| 463 | * back into the trace. |
---|
| 464 | * |
---|
| 465 | * @return array Array containing four strings: the filename, the line, |
---|
| 466 | * the function name, and the class name from which log() |
---|
| 467 | * was called. |
---|
| 468 | * |
---|
| 469 | * @access private |
---|
| 470 | * @since Log 1.9.4 |
---|
| 471 | */ |
---|
| 472 | function _getBacktraceVars($depth) |
---|
| 473 | { |
---|
| 474 | /* Start by generating a backtrace from the current call (here). */ |
---|
| 475 | $bt = debug_backtrace(); |
---|
| 476 | |
---|
| 477 | /* |
---|
| 478 | * If we were ultimately invoked by the composite handler, we need to |
---|
| 479 | * increase our depth one additional level to compensate. |
---|
| 480 | */ |
---|
| 481 | $class = isset($bt[$depth+1]['class']) ? $bt[$depth+1]['class'] : null; |
---|
| 482 | if ($class !== null && strcasecmp($class, 'Log_composite') == 0) { |
---|
| 483 | $depth++; |
---|
| 484 | $class = isset($bt[$depth + 1]) ? $bt[$depth + 1]['class'] : null; |
---|
| 485 | } |
---|
| 486 | |
---|
| 487 | /* |
---|
| 488 | * We're interested in the frame which invoked the log() function, so |
---|
| 489 | * we need to walk back some number of frames into the backtrace. The |
---|
| 490 | * $depth parameter tells us where to start looking. We go one step |
---|
| 491 | * further back to find the name of the encapsulating function from |
---|
| 492 | * which log() was called. |
---|
| 493 | */ |
---|
| 494 | $file = isset($bt[$depth]) ? $bt[$depth]['file'] : null; |
---|
| 495 | $line = isset($bt[$depth]) ? $bt[$depth]['line'] : 0; |
---|
| 496 | $func = isset($bt[$depth + 1]) ? $bt[$depth + 1]['function'] : null; |
---|
| 497 | |
---|
| 498 | /* |
---|
| 499 | * However, if log() was called from one of our "shortcut" functions, |
---|
| 500 | * we're going to need to go back an additional step. |
---|
| 501 | */ |
---|
| 502 | if (in_array($func, array('emerg', 'alert', 'crit', 'err', 'warning', |
---|
| 503 | 'notice', 'info', 'debug'))) { |
---|
| 504 | $file = isset($bt[$depth + 1]) ? $bt[$depth + 1]['file'] : null; |
---|
| 505 | $line = isset($bt[$depth + 1]) ? $bt[$depth + 1]['line'] : 0; |
---|
| 506 | $func = isset($bt[$depth + 2]) ? $bt[$depth + 2]['function'] : null; |
---|
| 507 | } |
---|
| 508 | |
---|
| 509 | /* |
---|
| 510 | * If we couldn't extract a function name (perhaps because we were |
---|
| 511 | * executed from the "main" context), provide a default value. |
---|
| 512 | */ |
---|
| 513 | if (is_null($func)) { |
---|
| 514 | $func = '(none)'; |
---|
| 515 | } |
---|
| 516 | |
---|
| 517 | /* Return a 4-tuple containing (file, line, function, class). */ |
---|
| 518 | return array($file, $line, $func, $class); |
---|
| 519 | } |
---|
| 520 | |
---|
| 521 | /** |
---|
| 522 | * Produces a formatted log line based on a format string and a set of |
---|
| 523 | * variables representing the current log record and state. |
---|
| 524 | * |
---|
| 525 | * @return string Formatted log string. |
---|
| 526 | * |
---|
| 527 | * @access protected |
---|
| 528 | * @since Log 1.9.4 |
---|
| 529 | */ |
---|
| 530 | function _format($format, $timestamp, $priority, $message) |
---|
| 531 | { |
---|
| 532 | /* |
---|
| 533 | * If the format string references any of the backtrace-driven |
---|
| 534 | * variables (%5 %6,%7,%8), generate the backtrace and fetch them. |
---|
| 535 | */ |
---|
| 536 | if (preg_match('/%[5678]/', $format)) { |
---|
| 537 | list($file, $line, $func, $class) = $this->_getBacktraceVars(2); |
---|
| 538 | } |
---|
| 539 | |
---|
| 540 | /* |
---|
| 541 | * Build the formatted string. We use the sprintf() function's |
---|
| 542 | * "argument swapping" capability to dynamically select and position |
---|
| 543 | * the variables which will ultimately appear in the log string. |
---|
| 544 | */ |
---|
| 545 | return sprintf($format, |
---|
| 546 | $timestamp, |
---|
| 547 | $this->_ident, |
---|
| 548 | $this->priorityToString($priority), |
---|
| 549 | $message, |
---|
| 550 | isset($file) ? $file : '', |
---|
| 551 | isset($line) ? $line : '', |
---|
| 552 | isset($func) ? $func : '', |
---|
| 553 | isset($class) ? $class : ''); |
---|
| 554 | } |
---|
| 555 | |
---|
| 556 | /** |
---|
| 557 | * Returns the string representation of a PEAR_LOG_* integer constant. |
---|
| 558 | * |
---|
| 559 | * @param int $priority A PEAR_LOG_* integer constant. |
---|
| 560 | * |
---|
| 561 | * @return string The string representation of $level. |
---|
| 562 | * |
---|
| 563 | * @access public |
---|
| 564 | * @since Log 1.0 |
---|
| 565 | */ |
---|
| 566 | function priorityToString($priority) |
---|
| 567 | { |
---|
| 568 | $levels = array( |
---|
| 569 | PEAR_LOG_EMERG => 'emergency', |
---|
| 570 | PEAR_LOG_ALERT => 'alert', |
---|
| 571 | PEAR_LOG_CRIT => 'critical', |
---|
| 572 | PEAR_LOG_ERR => 'error', |
---|
| 573 | PEAR_LOG_WARNING => 'warning', |
---|
| 574 | PEAR_LOG_NOTICE => 'notice', |
---|
| 575 | PEAR_LOG_INFO => 'info', |
---|
| 576 | PEAR_LOG_DEBUG => 'debug' |
---|
| 577 | ); |
---|
| 578 | |
---|
| 579 | return $levels[$priority]; |
---|
| 580 | } |
---|
| 581 | |
---|
| 582 | /** |
---|
| 583 | * Returns the the PEAR_LOG_* integer constant for the given string |
---|
| 584 | * representation of a priority name. This function performs a |
---|
| 585 | * case-insensitive search. |
---|
| 586 | * |
---|
| 587 | * @param string $name String containing a priority name. |
---|
| 588 | * |
---|
| 589 | * @return string The PEAR_LOG_* integer contstant corresponding |
---|
| 590 | * the the specified priority name. |
---|
| 591 | * |
---|
| 592 | * @access public |
---|
| 593 | * @since Log 1.9.0 |
---|
| 594 | */ |
---|
| 595 | function stringToPriority($name) |
---|
| 596 | { |
---|
| 597 | $levels = array( |
---|
| 598 | 'emergency' => PEAR_LOG_EMERG, |
---|
| 599 | 'alert' => PEAR_LOG_ALERT, |
---|
| 600 | 'critical' => PEAR_LOG_CRIT, |
---|
| 601 | 'error' => PEAR_LOG_ERR, |
---|
| 602 | 'warning' => PEAR_LOG_WARNING, |
---|
| 603 | 'notice' => PEAR_LOG_NOTICE, |
---|
| 604 | 'info' => PEAR_LOG_INFO, |
---|
| 605 | 'debug' => PEAR_LOG_DEBUG |
---|
| 606 | ); |
---|
| 607 | |
---|
| 608 | return $levels[strtolower($name)]; |
---|
| 609 | } |
---|
| 610 | |
---|
| 611 | /** |
---|
| 612 | * Calculate the log mask for the given priority. |
---|
| 613 | * |
---|
| 614 | * This method may be called statically. |
---|
| 615 | * |
---|
| 616 | * @param integer $priority The priority whose mask will be calculated. |
---|
| 617 | * |
---|
| 618 | * @return integer The calculated log mask. |
---|
| 619 | * |
---|
| 620 | * @access public |
---|
| 621 | * @since Log 1.7.0 |
---|
| 622 | */ |
---|
| 623 | function MASK($priority) |
---|
| 624 | { |
---|
| 625 | return (1 << $priority); |
---|
| 626 | } |
---|
| 627 | |
---|
| 628 | /** |
---|
| 629 | * Calculate the log mask for all priorities up to the given priority. |
---|
| 630 | * |
---|
| 631 | * This method may be called statically. |
---|
| 632 | * |
---|
| 633 | * @param integer $priority The maximum priority covered by this mask. |
---|
| 634 | * |
---|
| 635 | * @return integer The resulting log mask. |
---|
| 636 | * |
---|
| 637 | * @access public |
---|
| 638 | * @since Log 1.7.0 |
---|
| 639 | * |
---|
| 640 | * @deprecated deprecated since Log 1.9.4; use Log::MAX() instead |
---|
| 641 | */ |
---|
| 642 | function UPTO($priority) |
---|
| 643 | { |
---|
| 644 | return Log::MAX($priority); |
---|
| 645 | } |
---|
| 646 | |
---|
| 647 | /** |
---|
| 648 | * Calculate the log mask for all priorities greater than or equal to the |
---|
| 649 | * given priority. In other words, $priority will be the lowest priority |
---|
| 650 | * matched by the resulting mask. |
---|
| 651 | * |
---|
| 652 | * This method may be called statically. |
---|
| 653 | * |
---|
| 654 | * @param integer $priority The minimum priority covered by this mask. |
---|
| 655 | * |
---|
| 656 | * @return integer The resulting log mask. |
---|
| 657 | * |
---|
| 658 | * @access public |
---|
| 659 | * @since Log 1.9.4 |
---|
| 660 | */ |
---|
| 661 | function MIN($priority) |
---|
| 662 | { |
---|
| 663 | return PEAR_LOG_ALL ^ ((1 << $priority) - 1); |
---|
| 664 | } |
---|
| 665 | |
---|
| 666 | /** |
---|
| 667 | * Calculate the log mask for all priorities less than or equal to the |
---|
| 668 | * given priority. In other words, $priority will be the highests priority |
---|
| 669 | * matched by the resulting mask. |
---|
| 670 | * |
---|
| 671 | * This method may be called statically. |
---|
| 672 | * |
---|
| 673 | * @param integer $priority The maximum priority covered by this mask. |
---|
| 674 | * |
---|
| 675 | * @return integer The resulting log mask. |
---|
| 676 | * |
---|
| 677 | * @access public |
---|
| 678 | * @since Log 1.9.4 |
---|
| 679 | */ |
---|
| 680 | function MAX($priority) |
---|
| 681 | { |
---|
| 682 | return ((1 << ($priority + 1)) - 1); |
---|
| 683 | } |
---|
| 684 | |
---|
| 685 | /** |
---|
| 686 | * Set and return the level mask for the current Log instance. |
---|
| 687 | * |
---|
| 688 | * @param integer $mask A bitwise mask of log levels. |
---|
| 689 | * |
---|
| 690 | * @return integer The current level mask. |
---|
| 691 | * |
---|
| 692 | * @access public |
---|
| 693 | * @since Log 1.7.0 |
---|
| 694 | */ |
---|
| 695 | function setMask($mask) |
---|
| 696 | { |
---|
| 697 | $this->_mask = $mask; |
---|
| 698 | |
---|
| 699 | return $this->_mask; |
---|
| 700 | } |
---|
| 701 | |
---|
| 702 | /** |
---|
| 703 | * Returns the current level mask. |
---|
| 704 | * |
---|
| 705 | * @return interger The current level mask. |
---|
| 706 | * |
---|
| 707 | * @access public |
---|
| 708 | * @since Log 1.7.0 |
---|
| 709 | */ |
---|
| 710 | function getMask() |
---|
| 711 | { |
---|
| 712 | return $this->_mask; |
---|
| 713 | } |
---|
| 714 | |
---|
| 715 | /** |
---|
| 716 | * Check if the given priority is included in the current level mask. |
---|
| 717 | * |
---|
| 718 | * @param integer $priority The priority to check. |
---|
| 719 | * |
---|
| 720 | * @return boolean True if the given priority is included in the current |
---|
| 721 | * log mask. |
---|
| 722 | * |
---|
| 723 | * @access protected |
---|
| 724 | * @since Log 1.7.0 |
---|
| 725 | */ |
---|
| 726 | function _isMasked($priority) |
---|
| 727 | { |
---|
| 728 | return (Log::MASK($priority) & $this->_mask); |
---|
| 729 | } |
---|
| 730 | |
---|
| 731 | /** |
---|
| 732 | * Returns the current default priority. |
---|
| 733 | * |
---|
| 734 | * @return integer The current default priority. |
---|
| 735 | * |
---|
| 736 | * @access public |
---|
| 737 | * @since Log 1.8.4 |
---|
| 738 | */ |
---|
| 739 | function getPriority() |
---|
| 740 | { |
---|
| 741 | return $this->_priority; |
---|
| 742 | } |
---|
| 743 | |
---|
| 744 | /** |
---|
| 745 | * Sets the default priority to the specified value. |
---|
| 746 | * |
---|
| 747 | * @param integer $priority The new default priority. |
---|
| 748 | * |
---|
| 749 | * @access public |
---|
| 750 | * @since Log 1.8.4 |
---|
| 751 | */ |
---|
| 752 | function setPriority($priority) |
---|
| 753 | { |
---|
| 754 | $this->_priority = $priority; |
---|
| 755 | } |
---|
| 756 | |
---|
| 757 | /** |
---|
| 758 | * Adds a Log_observer instance to the list of observers that are listening |
---|
| 759 | * for messages emitted by this Log instance. |
---|
| 760 | * |
---|
| 761 | * @param object $observer The Log_observer instance to attach as a |
---|
| 762 | * listener. |
---|
| 763 | * |
---|
| 764 | * @param boolean True if the observer is successfully attached. |
---|
| 765 | * |
---|
| 766 | * @access public |
---|
| 767 | * @since Log 1.0 |
---|
| 768 | */ |
---|
| 769 | function attach(&$observer) |
---|
| 770 | { |
---|
| 771 | if (!is_a($observer, 'Log_observer')) { |
---|
| 772 | return false; |
---|
| 773 | } |
---|
| 774 | |
---|
| 775 | $this->_listeners[$observer->_id] = &$observer; |
---|
| 776 | |
---|
| 777 | return true; |
---|
| 778 | } |
---|
| 779 | |
---|
| 780 | /** |
---|
| 781 | * Removes a Log_observer instance from the list of observers. |
---|
| 782 | * |
---|
| 783 | * @param object $observer The Log_observer instance to detach from |
---|
| 784 | * the list of listeners. |
---|
| 785 | * |
---|
| 786 | * @param boolean True if the observer is successfully detached. |
---|
| 787 | * |
---|
| 788 | * @access public |
---|
| 789 | * @since Log 1.0 |
---|
| 790 | */ |
---|
| 791 | function detach($observer) |
---|
| 792 | { |
---|
| 793 | if (!is_a($observer, 'Log_observer') || |
---|
| 794 | !isset($this->_listeners[$observer->_id])) { |
---|
| 795 | return false; |
---|
| 796 | } |
---|
| 797 | |
---|
| 798 | unset($this->_listeners[$observer->_id]); |
---|
| 799 | |
---|
| 800 | return true; |
---|
| 801 | } |
---|
| 802 | |
---|
| 803 | /** |
---|
| 804 | * Informs each registered observer instance that a new message has been |
---|
| 805 | * logged. |
---|
| 806 | * |
---|
| 807 | * @param array $event A hash describing the log event. |
---|
| 808 | * |
---|
| 809 | * @access protected |
---|
| 810 | */ |
---|
| 811 | function _announce($event) |
---|
| 812 | { |
---|
| 813 | foreach ($this->_listeners as $id => $listener) { |
---|
| 814 | if ($event['priority'] <= $this->_listeners[$id]->_priority) { |
---|
| 815 | $this->_listeners[$id]->notify($event); |
---|
| 816 | } |
---|
| 817 | } |
---|
| 818 | } |
---|
| 819 | |
---|
| 820 | /** |
---|
| 821 | * Indicates whether this is a composite class. |
---|
| 822 | * |
---|
| 823 | * @return boolean True if this is a composite class. |
---|
| 824 | * |
---|
| 825 | * @access public |
---|
| 826 | * @since Log 1.0 |
---|
| 827 | */ |
---|
| 828 | function isComposite() |
---|
| 829 | { |
---|
| 830 | return false; |
---|
| 831 | } |
---|
| 832 | |
---|
| 833 | /** |
---|
| 834 | * Sets this Log instance's identification string. |
---|
| 835 | * |
---|
| 836 | * @param string $ident The new identification string. |
---|
| 837 | * |
---|
| 838 | * @access public |
---|
| 839 | * @since Log 1.6.3 |
---|
| 840 | */ |
---|
| 841 | function setIdent($ident) |
---|
| 842 | { |
---|
| 843 | $this->_ident = $ident; |
---|
| 844 | } |
---|
| 845 | |
---|
| 846 | /** |
---|
| 847 | * Returns the current identification string. |
---|
| 848 | * |
---|
| 849 | * @return string The current Log instance's identification string. |
---|
| 850 | * |
---|
| 851 | * @access public |
---|
| 852 | * @since Log 1.6.3 |
---|
| 853 | */ |
---|
| 854 | function getIdent() |
---|
| 855 | { |
---|
| 856 | return $this->_ident; |
---|
| 857 | } |
---|
| 858 | } |
---|