Example #1
0
File: log.php Project: cepharum/txf
 /**
  * Prepares use of logger.
  *
  * This method may be called to switch previous name of application. It
  * might be called at any time as it's preventing multiple preparations
  * internally.
  *
  * @param string $applicationName name of application to show in logs
  */
 public static function prepare($applicationName = null)
 {
     if (!self::$prepared || $applicationName !== null && $applicationName !== self::$prepared) {
         openlog($applicationName !== null ? "TXF.{$applicationName}" : 'TXF', LOG_NDELAY + LOG_PID, LOG_USER);
         self::$prepared = $applicationName !== null ? $applicationName : true;
     }
 }
Example #2
0
 function __construct($_sFeaturePath, $_iPort = 16816)
 {
     openlog("cuke4php", LOG_PID, LOG_DAEMON);
     if (is_file($_sFeaturePath)) {
         $_sFeaturePath = dirname($_sFeaturePath);
     }
     if ($_iPort > 0) {
         $this->iPort = $_iPort;
     } else {
         $this->iPort = 16816;
     }
     foreach (self::rglob("*.php", 0, $_sFeaturePath . "/support") as $sFilename) {
         require_once $sFilename;
     }
     set_error_handler(array('PHPUnit_Util_ErrorHandler', 'handleError'), E_ALL | E_STRICT);
     require_once "Cucumber.php";
     foreach (self::rglob("*.php", 0, $_sFeaturePath . "/step_definitions") as $sFilename) {
         require_once $sFilename;
     }
     $this->aStepClasses = CucumberSteps::getSubclasses();
     foreach ($this->aStepClasses as $sClass) {
         $oReflection = new ReflectionClass($sClass);
         $aMethods = $oReflection->getMethods();
         foreach ($aMethods as $oMethod) {
             $sComment = $oMethod->getDocComment();
             $aMatches = array();
             $aMethod = array();
             $aMethod['method'] = $oMethod->name;
             $aMethod['class'] = $oMethod->class;
             $aMethod['filename'] = $oMethod->getFileName();
             $aMethod['startline'] = $oMethod->getStartLine();
             if (substr($oMethod->name, 0, 4) === "step") {
                 preg_match("/(?:Given|When|Then) (.+)\$/im", $sComment, $aMatches);
                 $aMethod['regexp'] = $aMatches[1];
                 $this->aWorld['steps'][] = $aMethod;
                 continue;
             }
             preg_match("/(@.+)/im", $sComment, $aMatches);
             if (array_key_exists(1, $aMatches)) {
                 $aMethod['tags'] = explode(" ", str_replace("@", "", $aMatches[1]));
             } else {
                 $aMethod['tags'] = array();
             }
             if (substr($oMethod->name, 0, 6) === "before") {
                 $this->aWorld['before'][] = $aMethod;
                 continue;
             }
             if (substr($oMethod->name, 0, 5) === "after") {
                 $this->aWorld['after'][] = $aMethod;
                 continue;
             }
             if (substr($oMethod->name, 0, 9) == "transform") {
                 preg_match("/(?:Transform) (.+)\$/im", $sComment, $aMatches);
                 $aMethod['regexp'] = $aMatches[1];
                 $this->aWorld['transform'][] = $aMethod;
                 continue;
             }
         }
     }
 }
Example #3
0
 function __construct(array $params = array())
 {
     if (isset($params['application'])) {
         $this->_appName = $params['application'];
     }
     openlog($this->_appName, LOG_PID, LOG_USER);
 }
Example #4
0
 /**
  * Constructor.
  *
  * @param   array  &$options  Log object options.
  *
  * @since   11.1
  */
 public function __construct(array &$options)
 {
     // Call the parent constructor.
     parent::__construct($options);
     // Ensure that we have an identity string for the Syslog entries.
     if (empty($this->options['sys_ident'])) {
         $this->options['sys_ident'] = 'Joomla Platform';
     }
     // If the option to add the process id to Syslog entries is set use it, otherwise default to true.
     if (isset($this->options['sys_add_pid'])) {
         $this->options['sys_add_pid'] = (bool) $this->options['sys_add_pid'];
     } else {
         $this->options['sys_add_pid'] = true;
     }
     // If the option to also send Syslog entries to STDERR is set use it, otherwise default to false.
     if (isset($this->options['sys_use_stderr'])) {
         $this->options['sys_use_stderr'] = (bool) $this->options['sys_use_stderr'];
     } else {
         $this->options['sys_use_stderr'] = false;
     }
     // Build the Syslog options from our log object options.
     $sysOptions = 0;
     if ($this->options['sys_add_pid']) {
         $sysOptions = $sysOptions | LOG_PID;
     }
     if ($this->options['sys_use_stderr']) {
         $sysOptions = $sysOptions | LOG_PERROR;
     }
     // Open the Syslog connection.
     openlog((string) $this->options['sys_ident'], $sysOptions, LOG_USER);
 }
 public function write(string $level, string $message)
 {
     $l = LOG_INFO;
     $message = $this->interpolate($level, $message);
     switch ($level) {
         case 'emergency':
         case 'alert':
         case 'critical':
         case 'error':
         case 'warning':
             $l = LOG_WARNING;
             break;
         case 'notice':
             $l = LOG_NOTICE;
             break;
         case 'debug':
             $l = LOG_DEBUG;
             break;
         default:
             break;
     }
     if (\openlog($this->ident, LOG_PID, LOG_USER)) {
         \syslog($l, $message);
     }
 }
 /**
  * Opens a connection to the system logger, if it has not already
  * been opened.  This is implicitly called by log(), if necessary.
  * @access public
  */
 function open()
 {
     if (!$this->_opened) {
         $this->_opened = openlog($this->_ident, LOG_PID, $this->_name);
     }
     return $this->_opened;
 }
 function __construct($name = 'ykval')
 {
     $this->name = $name;
     $this->fields = array();
     $this->LOG_LEVELS = array(LOG_EMERG => 'LOG_EMERG', LOG_ALERT => 'LOG_ALERT', LOG_CRIT => 'LOG_CRIT', LOG_ERR => 'LOG_ERR', LOG_WARNING => 'LOG_WARNING', LOG_NOTICE => 'LOG_NOTICE', LOG_INFO => 'LOG_INFO', LOG_DEBUG => 'LOG_DEBUG');
     openlog("ykval", LOG_PID, LOG_LOCAL0);
 }
 /**
  * Write a log message to the log socket.
  *
  * @param int    $priority   The priority.
  * @param string $message    The message.
  * @param string $ident      Defaults to the ident set via setIdent()
  * @param int    $date       Timestamp for log message. Defaults to now.
  *
  * @return \YapepBase\Syslog\LegacySyslogConnection
  *
  * @throws \YapepBase\Exception\SyslogException on error
  * @throws \YapepBase\Exception\NotImplementedException if the date is set, because this implementation
  *                                                      doesn't support it.
  */
 public function log($priority, $message, $ident = null, $date = null)
 {
     $this->validatePriority($priority);
     $this->validateIdent($ident);
     if (!\is_null($date)) {
         throw new NotImplementedException('PHP\'s internal syslog functions don\'t support passing the date');
     }
     if (!is_string($ident)) {
         $ident = $this->ident;
     }
     if (!openlog($ident, $this->options, $this->facility)) {
         throw new SyslogException('openlog() failed');
     } else {
         if (!syslog($priority, $message)) {
             $e = new SyslogException('syslog() failed');
         }
         if (!closelog()) {
             if (isset($e)) {
                 throw new SyslogException('syslog() and closelog() failed');
             } else {
                 throw new SyslogException('closelog() failed');
             }
         } elseif (isset($e)) {
             throw $e;
         }
     }
     return $this;
 }
Example #9
0
function processData()
{
    $flag = false;
    $firstName = $_POST['firstname'];
    if (strlen($firstName) == 0) {
        $flag = true;
    }
    $lastName = $_POST['lastname'];
    if (strlen($lastName) == 0) {
        $flag = true;
    }
    $emailAddress = $_POST['emailaddress'];
    if (strlen($emailAddress) == 0) {
        $flag = true;
    }
    if ($flag == false) {
        openlog('php', LOG_CONS | LOG_NDELAY | LOG_PID, LOG_USER | LOG_PERROR);
        syslog(LOG_ERR, 'Error!');
        syslog(LOG_INFO, "{$firstName} {$lastName} {$emailAddress}");
        closelog();
        echo "<style type='text/css'>#formContainer{display:none;}</style>";
        echo "\n\t\t\t\t\t\t\t\t\t\t<h3 class='FormLabel'>SUCCESS!</h3>\n\t\t\t\t\t\t\t\t\t\tThank you for creating an account {$firstName} {$lastName}!\n\t\t\t\t\t\t\t\t\t\tA confirmation email has been sent to {$emailAddress}.\n\t\t\t\t\t\t\t\t\t\tOnce you receive this email please follow the instructions\n\t\t\t\t\t\t\t\t\t\tprovided to active your new account.\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t<h6>This page will refresh in 10 seconds...</h6>\n\t\t\t\t\t\t\t\t\t";
        header("refresh:10;url=index.php");
    }
}
Example #10
0
 public static function init($ident, $facility)
 {
     if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
         self::$facilities['local0'] = LOG_LOCAL0;
         self::$facilities['local1'] = LOG_LOCAL1;
         self::$facilities['local2'] = LOG_LOCAL2;
         self::$facilities['local3'] = LOG_LOCAL3;
         self::$facilities['local4'] = LOG_LOCAL4;
         self::$facilities['local5'] = LOG_LOCAL5;
         self::$facilities['local6'] = LOG_LOCAL6;
         self::$facilities['local7'] = LOG_LOCAL7;
     }
     if (array_key_exists(strtolower($facility), self::$facilities)) {
         $facility = self::$facilities[strtolower($facility)];
     } elseif (!in_array($facility, array_values(self::$facilities), true)) {
         throw new \UnexpectedValueException('Unknown facility value "' . $facility . '"');
     }
     return function ($info) use($ident, $facility) {
         if (!openlog($ident, LOG_PID, $facility)) {
             throw new \LogicException('Can\'t open syslog for ident "' . $ident . '" and facility "' . $facility . '"');
         }
         syslog(Syslog::$levels[$info['level']], vsprintf('%1$s: %4$s', $info));
         closelog();
     };
 }
Example #11
0
function logMessage($type, $level, $message)
{
    global $debug;
    global $use_syslog;
    if ($use_syslog) {
        define_syslog_variables();
        if ($debug) {
        }
        if ($level == 0) {
            $s_level = LOG_ERR;
        } else {
            if ($level == 1) {
                $s_level = LOG_WARNING;
            } else {
                if ($level == 2) {
                    $s_level = LOG_INFO;
                } else {
                    if ($level == 3) {
                        $s_level = LOG_DEBUG;
                    } else {
                        $s_level = LOG_ERR;
                    }
                }
            }
        }
        $s_message = $type . " " . $message;
        openlog("restbot", LOG_PID, LOG_DAEMON);
        syslog($s_level, $s_message);
        closelog();
    }
}
Example #12
0
function _log($text)
{
    _trace($text);
    openlog("alarm", LOG_PID | LOG_PERROR, LOG_LOCAL0);
    syslog(LOG_DEBUG, var_export($text));
    closelog();
}
Example #13
0
 /**
  * class constructor opens syslog with passed log ident and options
  *
  * @error 12101
  * @param string $ident expects log identifier
  * @param int $facility expects optional bitmasked values
  * @throws Xapp_Log_Writer_Exception
  */
 public function __construct($ident = 'Xapp', $facility = LOG_USER)
 {
     $this->_ident = trim((string) $ident);
     if (!openlog($this->_ident, LOG_CONS, $facility)) {
         throw new Xapp_Log_Writer_Exception(_("unable to open sys log with passed parameters"), 1210101);
     }
 }
Example #14
0
 public function __construct()
 {
     $this->config = \Jelix\Core\App::config()->syslogLogger;
     $this->catSyslog = array('error' => LOG_ERR, 'warning' => LOG_WARNING, 'notice' => LOG_NOTICE, 'deprecated' => LOG_NOTICE, 'strict' => LOG_NOTICE, 'debug' => LOG_DEBUG);
     $ident = strtr($this->config['ident'], array('%sapi%' => php_sapi_name(), '%domain%' => \Jelix\Core\App::config()->domainName, '%pid%' => getmypid()));
     openlog($ident, LOG_ODELAY | LOG_PERROR, $this->config['facility']);
 }
Example #15
0
 public function writeLog($message = null, $code = null)
 {
     if (empty($this->message) && empty($message)) {
         return;
     } else {
         $this->message = $message;
     }
     if (empty($this->code) && empty($code)) {
         $this->code = 0;
     } else {
         $this->code = $code;
     }
     if (openlog(LoggingConfig::LOG_IDENT, LOG_PID | LOG_CONS, LoggingConfig::LOG_FACILITY) === true) {
         $entries = explode("\n", $this->message);
         foreach ($entries as $entry) {
             syslog(LOG_INFO, sprintf("(%s) [%s] %s %s %s - %s", $this->ip, $this->user, strtoupper($this->method), $this->code, $this->uri, $entry));
         }
         if (LoggingConfig::LOG_DEBUG == true && !empty($this->input) && $this->input != "null") {
             syslog(LOG_DEBUG, sprintf("(%s) [%s] Input: %s", $this->ip, $this->user, $this->input));
         }
         if (LoggingConfig::LOG_DEBUG == true && !empty($this->output) && $this->output != "null") {
             syslog(LOG_DEBUG, sprintf("(%s) [%s] Output: %s", $this->ip, $this->user, $this->output));
         }
         closelog();
     } else {
         trigger_error("Could not open syslog facility", E_USER_ERROR);
     }
 }
Example #16
0
 public function log()
 {
     $argsNum = func_num_args();
     if ($argsNum < 2) {
         return false;
     }
     $args = func_get_args();
     $priority = $args[0];
     $message = $args[1];
     if ($priority > $this->allowPriority) {
         return false;
     }
     $priorityName = $this->getLevelName($priority);
     $strLog = '';
     if ($priorityName) {
         $strLog = "[{$priorityName}]";
     }
     $strLog .= "{$message}";
     for ($i = 2; $i < $argsNum; $i++) {
         $strLog .= $args[$i];
     }
     openlog('SPF', LOG_PID, LOG_USER);
     syslog($priority, $strLog);
     closelog();
 }
Example #17
0
 /**
  * {@inheritdoc}
  */
 protected function write(array $record)
 {
     if (!openlog($this->ident, $this->logopts, $this->facility)) {
         throw new \LogicException('Can\'t open syslog for ident "' . $this->ident . '" and facility "' . $this->facility . '"');
     }
     syslog($this->logLevels[$record['level']], (string) $record['formatted']);
 }
Example #18
0
 public static function write($stack)
 {
     if (self::$isOpen === false) {
         $default = array('ident' => 'PhotonApp', 'facility' => LOG_USER, 'option' => LOG_CONS | LOG_NDELAY | LOG_PID);
         $conf = Conf::f('log_syslog', $default);
         $conf = array_merge($default, $conf);
         // Windows can log only in LOG_USER
         if (substr(PHP_OS, 0, 3) === 'WIN') {
             $conf['facility'] = LOG_USER;
         }
         $rc = openlog($conf['ident'], $conf['option'], $conf['facility']);
         if ($rc === true) {
             self::$isOpen = true;
         }
     }
     foreach ($stack as $elt) {
         $level = self::$photon2syslog[$elt[1]];
         if (is_array($elt[2]) || is_object($elt[2])) {
             $msg = json_encode($elt[2]);
         } else {
             $msg = $elt[2];
         }
         syslog($level, $msg);
     }
     return false;
 }
 /**
  * @see \Components\Log_Appender_Abstract::initialize() initialize
  */
 public function initialize()
 {
     if (false === $this->m_initialized) {
         parent::initialize();
         openlog($this->name, $this->options, $this->facility);
     }
 }
function LogInfo($msg)
{
    global $argv;
    openlog($argv[0], LOG_PID, LOG_USER);
    syslog(LOG_INFO, $msg);
    closelog();
}
Example #21
0
 public function __construct($passthru = false, $ajax = false)
 {
     date_default_timezone_set('EST');
     if ($ajax) {
         $this->ajax = true;
     }
     $this->passthru = $passthru;
     error_reporting(E_ERROR | E_WARNING | E_PARSE);
     openlog(config::APP_NAMESPACE, 0, LOG_LOCAL0);
     $this->logFile = fopen(config::LOG_FILE, "a+");
     $this->initDB();
     // Bring up the database connection
     $this->initMemcache();
     $this->validateSession();
     // Session startup and login validator
     $this->escapeVars();
     // Sanitation
     $this->htmlData = base::init();
     if (!$passthru) {
         $this->buildUserObject();
     }
     // Build User Object
     if ($this->getSetting('stripe_private')) {
         Stripe::setApiKey($this->getSetting('stripe_private'));
     }
 }
Example #22
0
 /**
  * Opens a connection to the system logger, if it has not already
  * been opened.  This is implicitly called by log(), if necessary.
  * @access public
  */
 function open()
 {
     if (!$this->_opened) {
         openlog($this->_ident, LOG_PID, $this->_name);
         $this->_opened = true;
     }
 }
 /**
  * Constructs a new syslog writer with the identity $ident, options $option
  * and the facility $facility.
  *
  * The identity will be prepended to each log message in the syslog.
  *
  * The $option argument is used to indicate what logging options will be used
  * when generating a log message. See
  * {@link syslog() syslog} for more information on valid values for $option.
  * The default options are LOG_PID and LOG_ODELAY.
  *
  * The $facility argument is used to specify what type of program is logging
  * the message. This allows you to specify (in your machine's syslog configuration)
  * how messages coming from different facilities will be handled. See
  * {@link syslog() syslog} for more information on valid values for $facility.
  *
  * @param string $ident
  * @param int $option
  * @param int $facility
  */
 public function __construct($ident, $option = null, $facility = LOG_USER)
 {
     if ($option == null) {
         $option = LOG_PID | LOG_ODELAY;
     }
     openlog($ident, $option, $facility);
 }
Example #24
0
	/**
	 * Creates a new syslog logger.
	 *
	 * @see http://us2.php.net/openlog
	 *
	 * @param   string  syslog identifier
	 * @param   int     facility to log to
	 * @return  void
	 */
	public function __construct($ident = 'KohanaPHP', $facility = LOG_USER)
	{
		$this->_ident = $ident;

		// Open the connection to syslog
		openlog($this->_ident, LOG_CONS, $facility);
	}
Example #25
0
 /**
  * @param string $ident
  * @param mixed $facility
  * @param integer $level The minimum logging level at which this handler will be triggered
  * @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not
  */
 public function __construct($ident, $facility = LOG_USER, $level = Logger::DEBUG, $bubble = true)
 {
     parent::__construct($level, $bubble);
     if (false === strpos(PHP_OS, 'WIN')) {
         $this->facilities['local0'] = LOG_LOCAL0;
         $this->facilities['local1'] = LOG_LOCAL1;
         $this->facilities['local2'] = LOG_LOCAL2;
         $this->facilities['local3'] = LOG_LOCAL3;
         $this->facilities['local4'] = LOG_LOCAL4;
         $this->facilities['local5'] = LOG_LOCAL5;
         $this->facilities['local6'] = LOG_LOCAL6;
         $this->facilities['local7'] = LOG_LOCAL7;
     }
     // convert textual description of facility to syslog constant
     if (array_key_exists(strtolower($facility), $this->facilities)) {
         $facility = $this->facilities[strtolower($facility)];
     } else {
         if (!in_array($facility, array_values($this->facilities), true)) {
             throw new \UnexpectedValueException('Unknown facility value "' . $facility . '" given');
         }
     }
     if (!openlog($ident, LOG_PID, $facility)) {
         throw new \LogicException('Can\'t open syslog for ident "' . $ident . '" and facility "' . $facility . '"');
     }
 }
Example #26
0
function Debuglogs($text = null, $function = null, $line = null)
{
    if (!$GLOBALS["DEBUG"]) {
        return;
    }
    if ($text == null) {
        return;
    }
    $linetext = null;
    if ($function == null) {
        if (function_exists("debug_backtrace")) {
            $trace = @debug_backtrace();
        }
        if (is_array($trace)) {
            $filename = basename($trace[1]["file"]);
            $function = $trace[1]["function"];
            $line = $trace[1]["line"];
        }
    }
    $linetext = $text;
    if ($function != null) {
        $linetext = "{$function}/{$line} {$linetext}";
    } else {
        if ($line != null) {
            $linetext = "{$line} {$linetext}";
        }
    }
    if (function_exists("syslog")) {
        $LOG_SEV = LOG_INFO;
        openlog("error_page", LOG_PID, LOG_SYSLOG);
        syslog($LOG_SEV, $linetext);
        closelog();
    }
}
Example #27
0
 /**
  * Constructor
  *
  * @access	public
  */
 function OCS_Log()
 {
     // adapted from CI's Log.php
     $config =& get_config();
     if (is_numeric($config['log_threshold'])) {
         $this->_threshold = $config['log_threshold'];
     }
     if ($config['log_date_format'] != '') {
         $this->_date_fmt = $config['log_date_format'];
     }
     if (isset($config['log_backtrace_func'])) {
         $this->_backtrace_func = $config['log_backtrace_func'];
     }
     if (isset($config['log_backtrace_line'])) {
         $this->_backtrace_line = $config['log_backtrace_line'];
     }
     if (isset($config['log_use_syslog'])) {
         $this->_use_syslog = $config['log_use_syslog'];
     }
     if (isset($config['log_syslog_facility'])) {
         $this->_syslog_facility = $config['log_syslog_facility'];
     }
     if ($this->_use_syslog === TRUE) {
         if (!openlog("ocs", LOG_PID, $this->_syslog_facility)) {
             $this->_enable = FALSE;
         }
     } else {
         $this->log_path = $config['log_path'] != '' ? $config['log_path'] : BASEPATH . 'logs/';
         if (!is_dir($this->log_path) or !is_really_writable($this->log_path)) {
             $this->_enabled = FALSE;
         }
     }
 }
 /**
  * Open log file for append, and flush out buffered messages to the file.
  */
 public function open()
 {
     $this->fileHandle = openlog($this->signature, LOG_ODELAY | LOG_PID, LOG_LOCAL0);
     if ($this->fileHandle !== false && count($this->stack)) {
         $this->stackFlush();
     }
 }
Example #29
0
 public function write($uuid, $appName, $timestamp, $arguments)
 {
     openlog('WebSessionProfiler', LOG_PID, $this->_facility);
     $msg = array('wspid' => $uuid, 'appName' => $appName, 'timestamp' => $timestamp, 'message' => json_encode($arguments));
     $msg = json_encode($msg);
     syslog($this->_priority, $msg);
 }
Example #30
0
 /**
  *  $this->_write( int $level )
  *      @param      int     $level  - log level 
  *      @return     void 
  *      @access     public
  */
 public function write($level)
 {
     openlog($this->ident, $this->openlog_opt, $this->facility) or die(ERROR_CANT_OPEN_SYSLOG);
     $this->to_string(&$this->last_log);
     syslog(self::$id2syslog[$level], $this->last_log) or die(ERROR_CANT_WRITE_SYSLOG);
     closelog() or die(ERROR_CANT_CLOSE_SYSLOG);
 }