CRM/Core/Error.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.7                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2017                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  * Start of the Error framework. We should check out and inherit from
  30  * PEAR_ErrorStack and use that framework
  31  *
  32  * @package CRM
  33  * @copyright CiviCRM LLC (c) 2004-2017
  34  */
  35
  36 require_once 'PEAR/ErrorStack.php';
  37 require_once 'PEAR/Exception.php';
  38 require_once 'CRM/Core/Exception.php';
  39
  40 require_once 'Log.php';
  41
  42 /**
  43  * Class CRM_Exception
  44  */
  45 class CRM_Exception extends PEAR_Exception {
  46   /**
  47    * Redefine the exception so message isn't optional.
  48    *
  49    * Supported signatures:
  50    *  - PEAR_Exception(string $message);
  51    *  - PEAR_Exception(string $message, int $code);
  52    *  - PEAR_Exception(string $message, Exception $cause);
  53    *  - PEAR_Exception(string $message, Exception $cause, int $code);
  54    *  - PEAR_Exception(string $message, PEAR_Error $cause);
  55    *  - PEAR_Exception(string $message, PEAR_Error $cause, int $code);
  56    *  - PEAR_Exception(string $message, array $causes);
  57    *  - PEAR_Exception(string $message, array $causes, int $code);
  58    *
  59    * @param string $message exception message
  60    * @param int $code
  61    * @param Exception $previous
  62    */
  63   public function __construct($message = NULL, $code = 0, Exception $previous = NULL) {
  64     parent::__construct($message, $code, $previous);
  65   }
  66
  67 }
  68
  69 /**
  70  * Class CRM_Core_Error
  71  */
  72 class CRM_Core_Error extends PEAR_ErrorStack {
  73
  74   /**
  75    * Status code of various types of errors.
  76    */
  77   const FATAL_ERROR = 2;
  78   const DUPLICATE_CONTACT = 8001;
  79   const DUPLICATE_CONTRIBUTION = 8002;
  80   const DUPLICATE_PARTICIPANT = 8003;
  81
  82   /**
  83    * We only need one instance of this object. So we use the singleton
  84    * pattern and cache the instance in this variable
  85    * @var object
  86    */
  87   private static $_singleton = NULL;
  88
  89   /**
  90    * The logger object for this application.
  91    * @var object
  92    */
  93   private static $_log = NULL;
  94
  95   /**
  96    * If modeException == true, errors are raised as exception instead of returning civicrm_errors
  97    */
  98   public static $modeException = NULL;
  99
 100   /**
 101    * Singleton function used to manage this object.
 102    *
 103    * @param null $package
 104    * @param bool $msgCallback
 105    * @param bool $contextCallback
 106    * @param bool $throwPEAR_Error
 107    * @param string $stackClass
 108    *
 109    * @return object
 110    */
 111   public static function &singleton($package = NULL, $msgCallback = FALSE, $contextCallback = FALSE, $throwPEAR_Error = FALSE, $stackClass = 'PEAR_ErrorStack') {
 112     if (self::$_singleton === NULL) {
 113       self::$_singleton = new CRM_Core_Error('CiviCRM');
 114     }
 115     return self::$_singleton;
 116   }
 117
 118   /**
 119    * Constructor.
 120    */
 121   public function __construct() {
 122     parent::__construct('CiviCRM');
 123
 124     $log = CRM_Core_Config::getLog();
 125     $this->setLogger($log);
 126
 127     // PEAR<=1.9.0 does not declare "static" properly.
 128     if (!is_callable(array('PEAR', '__callStatic'))) {
 129       $this->setDefaultCallback(array($this, 'handlePES'));
 130     }
 131     else {
 132       PEAR_ErrorStack::setDefaultCallback(array($this, 'handlePES'));
 133     }
 134   }
 135
 136   /**
 137    * @param $error
 138    * @param string $separator
 139    *
 140    * @return array|null|string
 141    */
 142   static public function getMessages(&$error, $separator = '<br />') {
 143     if (is_a($error, 'CRM_Core_Error')) {
 144       $errors = $error->getErrors();
 145       $message = array();
 146       foreach ($errors as $e) {
 147         $message[] = $e['code'] . ': ' . $e['message'];
 148       }
 149       $message = implode($separator, $message);
 150       return $message;
 151     }
 152     return NULL;
 153   }
 154
 155   /**
 156    * Status display function specific to payment processor errors.
 157    * @param $error
 158    * @param string $separator
 159    */
 160   public static function displaySessionError(&$error, $separator = '<br />') {
 161     $message = self::getMessages($error, $separator);
 162     if ($message) {
 163       $status = ts("Payment Processor Error message") . "{$separator} $message";
 164       $session = CRM_Core_Session::singleton();
 165       $session->setStatus($status);
 166     }
 167   }
 168
 169   /**
 170    * Create the main callback method. this method centralizes error processing.
 171    *
 172    * the errors we expect are from the pear modules DB, DB_DataObject
 173    * which currently use PEAR::raiseError to notify of error messages.
 174    *
 175    * @param object $pearError PEAR_Error
 176    */
 177   public static function handle($pearError) {
 178     if (defined('CIVICRM_TEST')) {
 179       return self::simpleHandler($pearError);
 180     }
 181
 182     // setup smarty with config, session and template location.
 183     $template = CRM_Core_Smarty::singleton();
 184     $config = CRM_Core_Config::singleton();
 185
 186     if ($config->backtrace) {
 187       self::backtrace();
 188     }
 189
 190     // create the error array
 191     $error = self::getErrorDetails($pearError);
 192
 193     // We access connection info via _DB_DATAOBJECT instead
 194     // of, e.g., calling getDatabaseConnection(), so that we
 195     // can avoid infinite loops.
 196     global $_DB_DATAOBJECT;
 197
 198     if (isset($_DB_DATAOBJECT['CONFIG']['database'])) {
 199       $dao = new CRM_Core_DAO();
 200       if (isset($_DB_DATAOBJECT['CONNECTIONS'][$dao->_database_dsn_md5])) {
 201         $conn = $_DB_DATAOBJECT['CONNECTIONS'][$dao->_database_dsn_md5];
 202
 203         // FIXME: Polymorphism for the win.
 204         if ($conn instanceof DB_mysqli) {
 205           $link = $conn->connection;
 206           if (mysqli_error($link)) {
 207             $mysql_error = mysqli_error($link) . ', ' . mysqli_errno($link);
 208             mysqli_query($link, 'select 1'); // execute a dummy query to clear error stack
 209           }
 210         }
 211         elseif ($conn instanceof DB_mysql) {
 212           if (mysql_error()) {
 213             $mysql_error = mysql_error() . ', ' . mysql_errno();
 214             mysql_query('select 1'); // execute a dummy query to clear error stack
 215           }
 216         }
 217         else {
 218           $mysql_error = 'fixme-unknown-db-cxn';
 219         }
 220         $template->assign_by_ref('mysql_code', $mysql_error);
 221       }
 222     }
 223
 224     $template->assign_by_ref('error', $error);
 225     $errorDetails = CRM_Core_Error::debug('', $error, FALSE);
 226     $template->assign_by_ref('errorDetails', $errorDetails);
 227
 228     CRM_Core_Error::debug_var('Fatal Error Details', $error);
 229     CRM_Core_Error::backtrace('backTrace', TRUE);
 230
 231     if ($config->initialized) {
 232       $content = $template->fetch('CRM/common/fatal.tpl');
 233       echo CRM_Utils_System::theme($content);
 234     }
 235     else {
 236       echo "Sorry. A non-recoverable error has occurred. The error trace below might help to resolve the issue<p>";
 237       CRM_Core_Error::debug(NULL, $error);
 238     }
 239     static $runOnce = FALSE;
 240     if ($runOnce) {
 241       exit;
 242     }
 243     $runOnce = TRUE;
 244     self::abend(1);
 245   }
 246
 247   /**
 248    * this function is used to trap and print errors
 249    * during system initialization time. Hence the error
 250    * message is quite ugly
 251    *
 252    * @param $pearError
 253    */
 254   public static function simpleHandler($pearError) {
 255
 256     $error = self::getErrorDetails($pearError);
 257
 258     // ensure that debug does not check permissions since we are in bootstrap
 259     // mode and need to print a decent message to help the user
 260     CRM_Core_Error::debug('Initialization Error', $error, TRUE, TRUE, FALSE);
 261
 262     // always log the backtrace to a file
 263     self::backtrace('backTrace', TRUE);
 264
 265     exit(0);
 266   }
 267
 268   /**
 269    * this function is used to return error details
 270    *
 271    * @param $pearError
 272    *
 273    * @return array $error
 274    */
 275   public static function getErrorDetails($pearError) {
 276     // create the error array
 277     $error = array();
 278     $error['callback'] = $pearError->getCallback();
 279     $error['code'] = $pearError->getCode();
 280     $error['message'] = $pearError->getMessage();
 281     $error['mode'] = $pearError->getMode();
 282     $error['debug_info'] = $pearError->getDebugInfo();
 283     $error['type'] = $pearError->getType();
 284     $error['user_info'] = $pearError->getUserInfo();
 285     $error['to_string'] = $pearError->toString();
 286
 287     return $error;
 288   }
 289
 290   /**
 291    * Handle errors raised using the PEAR Error Stack.
 292    *
 293    * currently the handler just requests the PES framework
 294    * to push the error to the stack (return value PEAR_ERRORSTACK_PUSH).
 295    *
 296    * Note: we can do our own error handling here and return PEAR_ERRORSTACK_IGNORE.
 297    *
 298    * Also, if we do not return any value the PEAR_ErrorStack::push() then does the
 299    * action of PEAR_ERRORSTACK_PUSHANDLOG which displays the errors on the screen,
 300    * since the logger set for this error stack is 'display' - see CRM_Core_Config::getLog();
 301    *
 302    * @param mixed $pearError
 303    *
 304    * @return int
 305    */
 306   public static function handlePES($pearError) {
 307     return PEAR_ERRORSTACK_PUSH;
 308   }
 309
 310   /**
 311    * Display an error page with an error message describing what happened.
 312    *
 313    * @deprecated
 314    *  This is a really annoying function. We ❤ exceptions. Be exceptional!
 315    *
 316    * @see CRM-20181
 317    *
 318    * @param string $message
 319    *   The error message.
 320    * @param string $code
 321    *   The error code if any.
 322    * @param string $email
 323    *   The email address to notify of this situation.
 324    *
 325    * @throws Exception
 326    */
 327   public static function fatal($message = NULL, $code = NULL, $email = NULL) {
 328     $vars = array(
 329       'message' => htmlspecialchars($message),
 330       'code' => $code,
 331     );
 332
 333     if (self::$modeException) {
 334       // CRM-11043
 335       CRM_Core_Error::debug_var('Fatal Error Details', $vars);
 336       CRM_Core_Error::backtrace('backTrace', TRUE);
 337
 338       $details = 'A fatal error was triggered';
 339       if ($message) {
 340         $details .= ': ' . $message;
 341       }
 342       throw new Exception($details, $code);
 343     }
 344
 345     if (!$message) {
 346       $message = ts('We experienced an unexpected error. Please post a detailed description and the backtrace on the CiviCRM forums: %1', array(1 => 'http://forum.civicrm.org/'));
 347     }
 348
 349     if (php_sapi_name() == "cli") {
 350       print ("Sorry. A non-recoverable error has occurred.\n$message \n$code\n$email\n\n");
 351       // Fix for CRM-16899
 352       echo static::formatBacktrace(debug_backtrace());
 353       die("\n");
 354       // FIXME: Why doesn't this call abend()?
 355       // Difference: abend() will cleanup transaction and (via civiExit) store session state
 356       // self::abend(CRM_Core_Error::FATAL_ERROR);
 357     }
 358
 359     $config = CRM_Core_Config::singleton();
 360
 361     if ($config->fatalErrorHandler &&
 362       function_exists($config->fatalErrorHandler)
 363     ) {
 364       $name = $config->fatalErrorHandler;
 365       $ret = $name($vars);
 366       if ($ret) {
 367         // the call has been successfully handled
 368         // so we just exit
 369         self::abend(CRM_Core_Error::FATAL_ERROR);
 370       }
 371     }
 372
 373     if ($config->backtrace) {
 374       self::backtrace();
 375     }
 376
 377     CRM_Core_Error::debug_var('Fatal Error Details', $vars);
 378     CRM_Core_Error::backtrace('backTrace', TRUE);
 379
 380     // If we are in an ajax callback, format output appropriately
 381     if (CRM_Utils_Array::value('snippet', $_REQUEST) === CRM_Core_Smarty::PRINT_JSON) {
 382       $out = array(
 383         'status' => 'fatal',
 384         'content' => '<div class="messages status no-popup"><div class="icon inform-icon"></div>' . ts('Sorry but we are not able to provide this at the moment.') . '</div>',
 385       );
 386       if ($config->backtrace && CRM_Core_Permission::check('view debug output')) {
 387         $out['backtrace'] = self::parseBacktrace(debug_backtrace());
 388         $message .= '<p><em>See console for backtrace</em></p>';
 389       }
 390       CRM_Core_Session::setStatus($message, ts('Sorry an error occurred'), 'error');
 391       CRM_Core_Transaction::forceRollbackIfEnabled();
 392       CRM_Core_Page_AJAX::returnJsonResponse($out);
 393     }
 394
 395     $template = CRM_Core_Smarty::singleton();
 396     $template->assign($vars);
 397     $config->userSystem->outputError($template->fetch('CRM/common/fatal.tpl'));
 398
 399     self::abend(CRM_Core_Error::FATAL_ERROR);
 400   }
 401
 402   /**
 403    * Display an error page with an error message describing what happened.
 404    *
 405    * This function is evil -- it largely replicates fatal(). Hopefully the
 406    * entire CRM_Core_Error system can be hollowed out and replaced with
 407    * something that follows a cleaner separation of concerns.
 408    *
 409    * @param Exception $exception
 410    */
 411   public static function handleUnhandledException($exception) {
 412     try {
 413       CRM_Utils_Hook::unhandledException($exception);
 414     }
 415     catch (Exception $other) {
 416       // if the exception-handler generates an exception, then that sucks! oh, well. carry on.
 417       CRM_Core_Error::debug_var('handleUnhandledException_nestedException', self::formatTextException($other));
 418     }
 419     $config = CRM_Core_Config::singleton();
 420     $vars = array(
 421       'message' => $exception->getMessage(),
 422       'code' => NULL,
 423       'exception' => $exception,
 424     );
 425     if (!$vars['message']) {
 426       $vars['message'] = ts('We experienced an unexpected error. Please post a detailed description and the backtrace on the CiviCRM forums: %1', array(1 => 'http://forum.civicrm.org/'));
 427     }
 428
 429     // Case A: CLI
 430     if (php_sapi_name() == "cli") {
 431       printf("Sorry. A non-recoverable error has occurred.\n%s\n", $vars['message']);
 432       print self::formatTextException($exception);
 433       die("\n");
 434       // FIXME: Why doesn't this call abend()?
 435       // Difference: abend() will cleanup transaction and (via civiExit) store session state
 436       // self::abend(CRM_Core_Error::FATAL_ERROR);
 437     }
 438
 439     // Case B: Custom error handler
 440     if ($config->fatalErrorHandler &&
 441       function_exists($config->fatalErrorHandler)
 442     ) {
 443       $name = $config->fatalErrorHandler;
 444       $ret = $name($vars);
 445       if ($ret) {
 446         // the call has been successfully handled
 447         // so we just exit
 448         self::abend(CRM_Core_Error::FATAL_ERROR);
 449       }
 450     }
 451
 452     // Case C: Default error handler
 453
 454     // log to file
 455     CRM_Core_Error::debug_var('Fatal Error Details', $vars, FALSE);
 456     CRM_Core_Error::backtrace('backTrace', TRUE);
 457
 458     // print to screen
 459     $template = CRM_Core_Smarty::singleton();
 460     $template->assign($vars);
 461     $content = $template->fetch('CRM/common/fatal.tpl');
 462     if ($config->backtrace) {
 463       $content = self::formatHtmlException($exception) . $content;
 464     }
 465     if ($config->userFramework == 'Joomla' &&
 466       class_exists('JError')
 467     ) {
 468       JError::raiseError('CiviCRM-001', $content);
 469     }
 470     else {
 471       echo CRM_Utils_System::theme($content);
 472     }
 473
 474     // fin
 475     self::abend(CRM_Core_Error::FATAL_ERROR);
 476   }
 477
 478   /**
 479    * Outputs pre-formatted debug information. Flushes the buffers
 480    * so we can interrupt a potential POST/redirect
 481    *
 482    * @param string $name name of debug section
 483    * @param $variable mixed reference to variables that we need a trace of
 484    * @param bool $log should we log or return the output
 485    * @param bool $html whether to generate a HTML-escaped output
 486    * @param bool $checkPermission should we check permissions before displaying output
 487    *                useful when we die during initialization and permissioning
 488    *                subsystem is not initialized - CRM-13765
 489    *
 490    * @return string
 491    *   the generated output
 492    */
 493   public static function debug($name, $variable = NULL, $log = TRUE, $html = TRUE, $checkPermission = TRUE) {
 494     $error = self::singleton();
 495
 496     if ($variable === NULL) {
 497       $variable = $name;
 498       $name = NULL;
 499     }
 500
 501     $out = print_r($variable, TRUE);
 502     $prefix = NULL;
 503     if ($html) {
 504       $out = htmlspecialchars($out);
 505       if ($name) {
 506         $prefix = "<p>$name</p>";
 507       }
 508       $out = "{$prefix}<p><pre>$out</pre></p><p></p>";
 509     }
 510     else {
 511       if ($name) {
 512         $prefix = "$name:\n";
 513       }
 514       $out = "{$prefix}$out\n";
 515     }
 516     if (
 517       $log &&
 518       (!$checkPermission || CRM_Core_Permission::check('view debug output'))
 519     ) {
 520       echo $out;
 521     }
 522
 523     return $out;
 524   }
 525
 526   /**
 527    * Similar to the function debug. Only difference is
 528    * in the formatting of the output.
 529    *
 530    * @param string $variable_name
 531    *   Variable name.
 532    * @param mixed $variable
 533    *   Variable value.
 534    * @param bool $print
 535    *   Use print_r (if true) or var_dump (if false).
 536    * @param bool $log
 537    *   Log or return the output?
 538    * @param string $prefix
 539    *   Prefix for output logfile.
 540    *
 541    * @return string
 542    *   The generated output
 543    *
 544    * @see CRM_Core_Error::debug()
 545    * @see CRM_Core_Error::debug_log_message()
 546    */
 547   public static function debug_var($variable_name, $variable, $print = TRUE, $log = TRUE, $prefix = '') {
 548     // check if variable is set
 549     if (!isset($variable)) {
 550       $out = "\$$variable_name is not set";
 551     }
 552     else {
 553       if ($print) {
 554         $out = print_r($variable, TRUE);
 555         $out = "\$$variable_name = $out";
 556       }
 557       else {
 558         // use var_dump
 559         ob_start();
 560         var_dump($variable);
 561         $dump = ob_get_contents();
 562         ob_end_clean();
 563         $out = "\n\$$variable_name = $dump";
 564       }
 565       // reset if it is an array
 566       if (is_array($variable)) {
 567         reset($variable);
 568       }
 569     }
 570     return self::debug_log_message($out, FALSE, $prefix);
 571   }
 572
 573   /**
 574    * Display the error message on terminal and append it to the log file.
 575    *
 576    * Provided the user has the 'view debug output' the output should be displayed. In all
 577    * cases it should be logged.
 578    *
 579    * @param string $message
 580    * @param bool $out
 581    *   Should we log or return the output.
 582    *
 583    * @param string $prefix
 584    *   Message prefix.
 585    * @param string $priority
 586    *
 587    * @return string
 588    *   Format of the backtrace
 589    */
 590   public static function debug_log_message($message, $out = FALSE, $prefix = '', $priority = NULL) {
 591     $config = CRM_Core_Config::singleton();
 592
 593     $file_log = self::createDebugLogger($prefix);
 594     $file_log->log("$message\n", $priority);
 595
 596     $str = '<p/><code>' . htmlspecialchars($message) . '</code>';
 597     if ($out && CRM_Core_Permission::check('view debug output')) {
 598       echo $str;
 599     }
 600     $file_log->close();
 601
 602     if (!isset(\Civi::$statics[__CLASS__]['userFrameworkLogging'])) {
 603       // Set it to FALSE first & then try to set it. This is to prevent a loop as calling
 604       // $config->userFrameworkLogging can trigger DB queries & under log mode this
 605       // then gets called again.
 606       \Civi::$statics[__CLASS__]['userFrameworkLogging'] = FALSE;
 607       \Civi::$statics[__CLASS__]['userFrameworkLogging'] = $config->userFrameworkLogging;
 608     }
 609
 610     if (!empty(\Civi::$statics[__CLASS__]['userFrameworkLogging'])) {
 611       // should call $config->userSystem->logger($message) here - but I got a situation where userSystem was not an object - not sure why
 612       if ($config->userSystem->is_drupal and function_exists('watchdog')) {
 613         watchdog('civicrm', '%message', array('%message' => $message), WATCHDOG_DEBUG);
 614       }
 615     }
 616
 617     return $str;
 618   }
 619
 620   /**
 621    * Append to the query log (if enabled)
 622    *
 623    * @param string $string
 624    */
 625   public static function debug_query($string) {
 626     if (defined('CIVICRM_DEBUG_LOG_QUERY')) {
 627       if (CIVICRM_DEBUG_LOG_QUERY === 'backtrace') {
 628         CRM_Core_Error::backtrace($string, TRUE);
 629       }
 630       elseif (CIVICRM_DEBUG_LOG_QUERY) {
 631         CRM_Core_Error::debug_var('Query', $string, TRUE, TRUE, 'sql_log');
 632       }
 633     }
 634   }
 635
 636   /**
 637    * Execute a query and log the results.
 638    *
 639    * @param string $query
 640    */
 641   public static function debug_query_result($query) {
 642     $results = CRM_Core_DAO::executeQuery($query)->fetchAll();
 643     CRM_Core_Error::debug_var('dao result', array('query' => $query, 'results' => $results));
 644   }
 645
 646   /**
 647    * Obtain a reference to the error log.
 648    *
 649    * @param string $prefix
 650    *
 651    * @return Log
 652    */
 653   public static function createDebugLogger($prefix = '') {
 654     self::generateLogFileName($prefix);
 655     return Log::singleton('file', \Civi::$statics[__CLASS__]['logger_file' . $prefix], '');
 656   }
 657
 658   /**
 659    * Generate a hash for the logfile.
 660    *
 661    * CRM-13640.
 662    *
 663    * @param CRM_Core_Config $config
 664    *
 665    * @return string
 666    */
 667   public static function generateLogFileHash($config) {
 668     // Use multiple (but stable) inputs for hash information.
 669     $md5inputs = array(
 670       defined('CIVICRM_SITE_KEY') ? CIVICRM_SITE_KEY : 'NO_SITE_KEY',
 671       $config->userFrameworkBaseURL,
 672       md5($config->dsn),
 673       $config->dsn,
 674     );
 675     // Trim 8 chars off the string, make it slightly easier to find
 676     // but reveals less information from the hash.
 677     return substr(md5(var_export($md5inputs, 1)), 8);
 678   }
 679
 680   /**
 681    * Generate the name of the logfile to use and store it as a static.
 682    *
 683    * This function includes simplistic log rotation and a check as to whether
 684    * the file exists.
 685    *
 686    * @param string $prefix
 687    */
 688   protected static function generateLogFileName($prefix) {
 689     if (!isset(\Civi::$statics[__CLASS__]['logger_file' . $prefix])) {
 690       $config = CRM_Core_Config::singleton();
 691
 692       $prefixString = $prefix ? ($prefix . '.') : '';
 693
 694       $hash = self::generateLogFileHash($config);
 695       $fileName = $config->configAndLogDir . 'CiviCRM.' . $prefixString . $hash . '.log';
 696
 697       // Roll log file monthly or if greater than 256M.
 698       // Size-based rotation introduced in response to filesize limits on
 699       // certain OS/PHP combos.
 700       if (file_exists($fileName)) {
 701         $fileTime = date("Ym", filemtime($fileName));
 702         $fileSize = filesize($fileName);
 703         if (($fileTime < date('Ym')) ||
 704           ($fileSize > 256 * 1024 * 1024) ||
 705           ($fileSize < 0)
 706         ) {
 707           rename($fileName,
 708             $fileName . '.' . date('YmdHi')
 709           );
 710         }
 711       }
 712       \Civi::$statics[__CLASS__]['logger_file' . $prefix] = $fileName;
 713     }
 714   }
 715
 716   /**
 717    * @param string $msg
 718    * @param bool $log
 719    */
 720   public static function backtrace($msg = 'backTrace', $log = FALSE) {
 721     $backTrace = debug_backtrace();
 722     $message = self::formatBacktrace($backTrace);
 723     if (!$log) {
 724       CRM_Core_Error::debug($msg, $message);
 725     }
 726     else {
 727       CRM_Core_Error::debug_var($msg, $message);
 728     }
 729   }
 730
 731   /**
 732    * Render a backtrace array as a string.
 733    *
 734    * @param array $backTrace
 735    *   Array of stack frames.
 736    * @param bool $showArgs
 737    *   TRUE if we should try to display content of function arguments (which could be sensitive); FALSE to display only the type of each function argument.
 738    * @param int $maxArgLen
 739    *   Maximum number of characters to show from each argument string.
 740    * @return string
 741    *   printable plain-text
 742    */
 743   public static function formatBacktrace($backTrace, $showArgs = TRUE, $maxArgLen = 80) {
 744     $message = '';
 745     foreach (self::parseBacktrace($backTrace, $showArgs, $maxArgLen) as $idx => $trace) {
 746       $message .= sprintf("#%s %s\n", $idx, $trace);
 747     }
 748     $message .= sprintf("#%s {main}\n", 1 + $idx);
 749     return $message;
 750   }
 751
 752   /**
 753    * Render a backtrace array as an array.
 754    *
 755    * @param array $backTrace
 756    *   Array of stack frames.
 757    * @param bool $showArgs
 758    *   TRUE if we should try to display content of function arguments (which could be sensitive); FALSE to display only the type of each function argument.
 759    * @param int $maxArgLen
 760    *   Maximum number of characters to show from each argument string.
 761    * @return array
 762    * @see debug_backtrace
 763    * @see Exception::getTrace()
 764    */
 765   public static function parseBacktrace($backTrace, $showArgs = TRUE, $maxArgLen = 80) {
 766     $ret = array();
 767     foreach ($backTrace as $trace) {
 768       $args = array();
 769       $fnName = CRM_Utils_Array::value('function', $trace);
 770       $className = isset($trace['class']) ? ($trace['class'] . $trace['type']) : '';
 771
 772       // Do not show args for a few password related functions
 773       $skipArgs = ($className == 'DB::' && $fnName == 'connect') ? TRUE : FALSE;
 774
 775       if (!empty($trace['args'])) {
 776         foreach ($trace['args'] as $arg) {
 777           if (!$showArgs || $skipArgs) {
 778             $args[] = '(' . gettype($arg) . ')';
 779             continue;
 780           }
 781           switch ($type = gettype($arg)) {
 782             case 'boolean':
 783               $args[] = $arg ? 'TRUE' : 'FALSE';
 784               break;
 785
 786             case 'integer':
 787             case 'double':
 788               $args[] = $arg;
 789               break;
 790
 791             case 'string':
 792               $args[] = '"' . CRM_Utils_String::ellipsify(addcslashes((string) $arg, "\r\n\t\""), $maxArgLen) . '"';
 793               break;
 794
 795             case 'array':
 796               $args[] = '(Array:' . count($arg) . ')';
 797               break;
 798
 799             case 'object':
 800               $args[] = 'Object(' . get_class($arg) . ')';
 801               break;
 802
 803             case 'resource':
 804               $args[] = 'Resource';
 805               break;
 806
 807             case 'NULL':
 808               $args[] = 'NULL';
 809               break;
 810
 811             default:
 812               $args[] = "($type)";
 813               break;
 814           }
 815         }
 816       }
 817
 818       $ret[] = sprintf(
 819         "%s(%s): %s%s(%s)",
 820         CRM_Utils_Array::value('file', $trace, '[internal function]'),
 821         CRM_Utils_Array::value('line', $trace, ''),
 822         $className,
 823         $fnName,
 824         implode(", ", $args)
 825       );
 826     }
 827     return $ret;
 828   }
 829
 830   /**
 831    * Render an exception as HTML string.
 832    *
 833    * @param Exception $e
 834    * @return string
 835    *   printable HTML text
 836    */
 837   public static function formatHtmlException(Exception $e) {
 838     $msg = '';
 839
 840     // Exception metadata
 841
 842     // Exception backtrace
 843     if ($e instanceof PEAR_Exception) {
 844       $ei = $e;
 845       while (is_callable(array($ei, 'getCause'))) {
 846         if ($ei->getCause() instanceof PEAR_Error) {
 847           $msg .= '<table class="crm-db-error">';
 848           $msg .= sprintf('<thead><tr><th>%s</th><th>%s</th></tr></thead>', ts('Error Field'), ts('Error Value'));
 849           $msg .= '<tbody>';
 850           foreach (array('Type', 'Code', 'Message', 'Mode', 'UserInfo', 'DebugInfo') as $f) {
 851             $msg .= sprintf('<tr><td>%s</td><td>%s</td></tr>', $f, call_user_func(array($ei->getCause(), "get$f")));
 852           }
 853           $msg .= '</tbody></table>';
 854         }
 855         $ei = $ei->getCause();
 856       }
 857       $msg .= $e->toHtml();
 858     }
 859     else {
 860       $msg .= '<p><b>' . get_class($e) . ': "' . htmlentities($e->getMessage()) . '"</b></p>';
 861       $msg .= '<pre>' . htmlentities(self::formatBacktrace($e->getTrace())) . '</pre>';
 862     }
 863     return $msg;
 864   }
 865
 866   /**
 867    * Write details of an exception to the log.
 868    *
 869    * @param Exception $e
 870    * @return string
 871    *   printable plain text
 872    */
 873   public static function formatTextException(Exception $e) {
 874     $msg = get_class($e) . ": \"" . $e->getMessage() . "\"\n";
 875
 876     $ei = $e;
 877     while (is_callable(array($ei, 'getCause'))) {
 878       if ($ei->getCause() instanceof PEAR_Error) {
 879         foreach (array('Type', 'Code', 'Message', 'Mode', 'UserInfo', 'DebugInfo') as $f) {
 880           $msg .= sprintf(" * ERROR %s: %s\n", strtoupper($f), call_user_func(array($ei->getCause(), "get$f")));
 881         }
 882       }
 883       $ei = $ei->getCause();
 884     }
 885     $msg .= self::formatBacktrace($e->getTrace());
 886     return $msg;
 887   }
 888
 889   /**
 890    * @param $message
 891    * @param int $code
 892    * @param string $level
 893    * @param array $params
 894    *
 895    * @return object
 896    */
 897   public static function createError($message, $code = 8000, $level = 'Fatal', $params = NULL) {
 898     $error = CRM_Core_Error::singleton();
 899     $error->push($code, $level, array($params), $message);
 900     return $error;
 901   }
 902
 903   /**
 904    * Set a status message in the session, then bounce back to the referrer.
 905    *
 906    * @param string $status
 907    *   The status message to set.
 908    *
 909    * @param null $redirect
 910    * @param string $title
 911    */
 912   public static function statusBounce($status, $redirect = NULL, $title = NULL) {
 913     $session = CRM_Core_Session::singleton();
 914     if (!$redirect) {
 915       $redirect = $session->readUserContext();
 916     }
 917     if ($title === NULL) {
 918       $title = ts('Error');
 919     }
 920     $session->setStatus($status, $title, 'alert', array('expires' => 0));
 921     if (CRM_Utils_Array::value('snippet', $_REQUEST) === CRM_Core_Smarty::PRINT_JSON) {
 922       CRM_Core_Page_AJAX::returnJsonResponse(array('status' => 'error'));
 923     }
 924     CRM_Utils_System::redirect($redirect);
 925   }
 926
 927   /**
 928    * Reset the error stack.
 929    *
 930    */
 931   public static function reset() {
 932     $error = self::singleton();
 933     $error->_errors = array();
 934     $error->_errorsByLevel = array();
 935   }
 936
 937   /**
 938    * PEAR error-handler which converts errors to exceptions
 939    *
 940    * @param $pearError
 941    * @throws PEAR_Exception
 942    */
 943   public static function exceptionHandler($pearError) {
 944     CRM_Core_Error::debug_var('Fatal Error Details', self::getErrorDetails($pearError));
 945     CRM_Core_Error::backtrace('backTrace', TRUE);
 946     throw new PEAR_Exception($pearError->getMessage(), $pearError);
 947   }
 948
 949   /**
 950    * PEAR error-handler to quietly catch otherwise fatal errors. Intended for use with smtp transport.
 951    *
 952    * @param object $obj
 953    *   The PEAR_ERROR object.
 954    * @return object
 955    *   $obj
 956    */
 957   public static function nullHandler($obj) {
 958     CRM_Core_Error::debug_log_message("Ignoring exception thrown by nullHandler: {$obj->code}, {$obj->message}");
 959     CRM_Core_Error::backtrace('backTrace', TRUE);
 960     return $obj;
 961   }
 962
 963   /**
 964    * @deprecated
 965    * This function is no longer used by v3 api.
 966    * @fixme Some core files call it but it should be re-thought & renamed or removed
 967    *
 968    * @param $msg
 969    * @param null $data
 970    *
 971    * @return array
 972    * @throws Exception
 973    */
 974   public static function &createAPIError($msg, $data = NULL) {
 975     if (self::$modeException) {
 976       throw new Exception($msg, $data);
 977     }
 978
 979     $values = array();
 980
 981     $values['is_error'] = 1;
 982     $values['error_message'] = $msg;
 983     if (isset($data)) {
 984       $values = array_merge($values, $data);
 985     }
 986     return $values;
 987   }
 988
 989   /**
 990    * @param $file
 991    */
 992   public static function movedSiteError($file) {
 993     $url = CRM_Utils_System::url('civicrm/admin/setting/updateConfigBackend',
 994       'reset=1',
 995       TRUE
 996     );
 997     echo "We could not write $file. Have you moved your site directory or server?<p>";
 998     echo "Please fix the setting by running the <a href=\"$url\">update config script</a>";
 999     exit();
1000   }
1001
1002   /**
1003    * Terminate execution abnormally.
1004    *
1005    * @param string $code
1006    */
1007   protected static function abend($code) {
1008     // do a hard rollback of any pending transactions
1009     // if we've come here, its because of some unexpected PEAR errors
1010     CRM_Core_Transaction::forceRollbackIfEnabled();
1011     CRM_Utils_System::civiExit($code);
1012   }
1013
1014   /**
1015    * @param array $error
1016    * @param int $type
1017    *
1018    * @return bool
1019    */
1020   public static function isAPIError($error, $type = CRM_Core_Error::FATAL_ERROR) {
1021     if (is_array($error) && !empty($error['is_error'])) {
1022       $code = $error['error_message']['code'];
1023       if ($code == $type) {
1024         return TRUE;
1025       }
1026     }
1027     return FALSE;
1028   }
1029
1030 }
1031
1032 $e = new PEAR_ErrorStack('CRM');
1033 $e->singleton('CRM', FALSE, NULL, 'CRM_Core_Error');