PHP AbstractProcessingHandler::__construct方法代碼示例

 /**
  * @param  string $slackTeam Slack team slug
  * @param  string $token     Slackbot token
  * @param  string $channel   Slack channel (encoded ID or name)
  * @param  int    $level     The minimum logging level at which this handler will be triggered
  * @param  bool   $bubble    Whether the messages that are handled can bubble up the stack or not
  */
 public function __construct($slackTeam, $token, $channel, $level = Logger::CRITICAL, $bubble = true)
 {
     parent::__construct($level, $bubble);
     $this->slackTeam = $slackTeam;
     $this->token = $token;
     $this->channel = $channel;
 }

 public function __construct(MessageSender $sender, SmsapiFormatterFactory $formatterFactory, SmsapiConfig $config)
 {
     parent::__construct($config->handlerLoggerLevel, $config->handlerBubble);
     $this->sender = $sender;
     $this->formatterFactory = $formatterFactory;
     $this->config = $config;
 }

 /**
  * SlackWebhookHandler constructor.
  *
  * @param SlackConfig $slackConfig
  * @param MonologConfig $monologConfig
  *
  * @throws MissingExtensionException When the curl extension is not activated
  */
 public function __construct(SlackConfig $slackConfig, MonologConfig $monologConfig, Curl\Util $curlUtil)
 {
     parent::__construct($monologConfig->getLevel(), $monologConfig->doesBubble());
     $this->slackConfig = $slackConfig;
     $this->monologConfig = $monologConfig;
     $this->curlUtil = $curlUtil;
 }

 /**
  * @param string $name
  * @param int $level
  * @param bool $bubble
  */
 public function __construct($name, $level = Logger::DEBUG, $bubble = true)
 {
     parent::__construct($level, $bubble);
     $this->name = $name;
     $this->notifier = JoliNotif\NotifierFactory::create();
     $this->notification = new JoliNotif\Notification();
 }

 /**
  * {@inheritdoc}
  *
  * @param null $function The raising function, if not set the channel name is used.
  * @param null $action   The log action, if not set the level is used.
  */
 public function __construct($level = Logger::DEBUG, $bubble = true, $function = null, $action = null)
 {
     parent::__construct($level, $bubble);
     $this->function = $function;
     $this->action = $action;
     $this->adapter = new ContaoHandlerAdapter();
 }

 /**
  * @param int       $logName
  * @param bool|int  $level
  * @param bool|true $bubble
  */
 public function __construct($logName, $level = Logger::DEBUG, $bubble = true)
 {
     $this->logName = $logName;
     $log = get_option($this->logName);
     $this->logs = is_array($log) ? $log : array();
     parent::__construct($level, $bubble);
 }

 public function __construct(OutputInterface $output = null, $bubble = true, array $verbosityLevelMap = array())
 {
     parent::__construct(Logger::DEBUG, $bubble);
     if ($verbosityLevelMap) {
         $this->verbosityLevelMap = $verbosityLevelMap;
     }
 }

 public function __construct($hooksurl, $channel, $username, $level = Logger::ERROR, $bubble = true)
 {
     parent::__construct($level, $bubble);
     $this->hooksurl = $hooksurl;
     $this->channel = $channel;
     $this->username = $username;
 }

 /**
  * @param string       $account_sid       Twilio api account sid
  * @param string       $auth_token        Twilio api access token
  * @param string|array $from_numbers      Phone number or array of numbers (one is selected randomly)
  *                                          the message will be sent from.
  * @param string|array $to_numbers        Phone number or array of numbers the message will be sent to
  * @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($account_sid, $auth_token, $from_numbers, $to_numbers, $level = Logger::CRITICAL, $bubble = true)
 {
     $this->twilio_client = new \Services_Twilio($account_sid, $auth_token);
     $this->to_numbers = (array) $to_numbers;
     $this->from_numbers = (array) $from_numbers;
     parent::__construct($level, $bubble);
 }

 /**
  * $topic_arn is name of a topic that you have created either in the control panel or
  * using AmazonSNS->create_topic
  *
  * For the $snsClient pass a a ready SnsClient, depending ony your setup
  * More info http://docs.aws.amazon.com/aws-sdk-php/guide/latest/service-sns.html
  *
  * @param string $topicArn The name of the SNS topic to publish to
  * @param string $subject Used for email subscriptions to the topic
  * @param SnsClient $snsClient The Sns client
  * @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($topicArn, $subject, SnsClient $snsClient, $level = Logger::DEBUG, $bubble = true)
 {
     parent::__construct($level, $bubble);
     $this->topicArn = $topicArn;
     $this->subject = $subject;
     $this->sns = $snsClient;
 }

 public function __construct(EntityManager $em, TokenStorageInterface $tokenStorage, Request $request, $level = Logger::DEBUG, $bubble = true)
 {
     $this->em = $em;
     $this->tokenStorage = $tokenStorage;
     $this->request = $request;
     parent::__construct($level, $bubble);
 }

 public function __construct($url = null, $apiParametersArray = array(), $logMessageKeyName = "message", $level = Logger::DEBUG, $bubble = true)
 {
     $this->apiURL = $url;
     $this->apiParametersArray = $apiParametersArray;
     $this->logMessageKeyName = $logMessageKeyName;
     parent::__construct($level, $bubble);
 }

 /**
  * {@inheritDoc}
  *
  * @param string $appName
  * @param boolean $explodeArrays
  * @param string $transactionName
  */
 public function __construct($level = Logger::ERROR, $bubble = true, $appName = null, $explodeArrays = false, $transactionName = null)
 {
     parent::__construct($level, $bubble);
     $this->appName = $appName;
     $this->explodeArrays = $explodeArrays;
     $this->transactionName = $transactionName;
 }

 /**
  *
  * @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($level = Logger::DEBUG, $bubble = true)
 {
     parent::__construct($level, $bubble);
     if (!function_exists('json_encode')) {
         throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s ChromePHPHandler');
     }
 }

 /**
  * Construct
  *
  * @param  int $level
  * @param  bool $bubble
  * @throws MissingExtensionException
  */
 public function __construct($level = Logger::DEBUG, $bubble = true)
 {
     if (!function_exists('zend_monitor_custom_event')) {
         throw new MissingExtensionException('You must have Zend Server installed in order to use this handler');
     }
     parent::__construct($level, $bubble);
 }