/**
* Override main() to handle action
* Starts a Queuesadilla worker
*
* @return void
*/
public function main()
{
$logger = Log::engine($this->getLoggerName('stdout'));
$engine = $this->getEngine($logger);
$worker = $this->getWorker($engine, $logger);
$worker->work();
}
/**
* Get the summary data.
*
* @return string
*/
public function summary()
{
$logger = Log::engine('debug_kit_log_panel');
if (!$logger) {
return 0;
}
return $logger->count();
}
/**
* Override main() to handle action
* Starts a Queuesadilla worker
*
* @return void
*/
public function main()
{
$engine = $this->params['engine'];
$worker = $this->params['worker'];
$EngineClass = "josegonzalez\\Queuesadilla\\Engine\\" . $engine . 'Engine';
$WorkerClass = "josegonzalez\\Queuesadilla\\Worker\\" . $worker . "Worker";
$config = $this->getEngineConfig();
$loggerName = $this->getLoggerName();
$logger = Log::engine($loggerName);
$engine = new $EngineClass($logger, $config);
$worker = new $WorkerClass($engine, $logger);
$worker->work();
}
/**
* Create the queue engine instance.
*
* Part of the template method for Cake\Core\ObjectRegistry::load()
*
* @param string|\josegonzalez\Queuesadilla\Engine\EngineInterface $class The classname or object to make.
* @param string $alias The alias of the object.
* @param array $settings An array of settings to use for the queue engine.
* @return \josegonzalez\Queuesadilla\Engine\EngineInterface The constructed queue engine class.
* @throws \RuntimeException when an object doesn't implement the correct interface.
*/
protected function _create($class, $alias, $settings)
{
if (is_callable($class)) {
$class = $class($alias);
}
if (is_object($class)) {
$instance = $class;
}
if (!isset($instance)) {
$key = PHP_SAPI === 'cli' ? 'stdout' : 'default';
$logger = Hash::get($settings, 'logger', $key);
if (!$logger instanceof LoggerInterface) {
$logger = Log::engine($logger);
}
$instance = new $class($logger, $settings);
}
if ($instance instanceof EngineInterface) {
return $instance;
}
throw new RuntimeException('Queue Engines must implement josegonzalez\\Queuesadilla\\Engine\\EngineInterface.');
}
/**
* Tests using a callable for creating a Log engine
*
* @return void
*/
public function testCreateLoggerWithCallable()
{
$instance = new FileLog();
Log::config('default', function () use($instance) {
return $instance;
});
$this->assertSame($instance, Log::engine('default'));
}
/**
* Tests that setLoggers works properly with verbose
*
* @return void
*/
public function testSetLoggersVerbose()
{
Log::drop('stdout');
Log::drop('stderr');
$this->io->setLoggers(ConsoleIo::VERBOSE);
$this->assertNotEmpty(Log::engine('stderr'));
$engine = Log::engine('stdout');
$this->assertEquals(['notice', 'info', 'debug'], $engine->config('levels'));
}
/**
* Tests that the logged query object is passed to the built-in logger using
* the correct scope
*
* @return void
*/
public function testLogFunction()
{
$logger = new QueryLogger();
$query = new LoggedQuery();
$query->query = 'SELECT a FROM b where a = ? AND b = ? AND c = ?';
$query->params = ['string', '3', null];
$engine = $this->getMock('\\Cake\\Log\\Engine\\BaseLog', ['log'], ['scopes' => ['queriesLog']]);
Log::engine('queryLoggerTest', $engine);
$engine2 = $this->getMock('\\Cake\\Log\\Engine\\BaseLog', ['log'], ['scopes' => ['foo']]);
Log::engine('queryLoggerTest2', $engine2);
$engine2->expects($this->never())->method('log');
$logger->log($query);
}
/**
* Tests that setLoggers works properly
*
* @return void
*/
public function testSetLoggers()
{
Log::drop('stdout');
Log::drop('stderr');
$this->io->setLoggers(true);
$this->assertNotEmpty(Log::engine('stdout'));
$this->assertNotEmpty(Log::engine('stderr'));
$this->io->setLoggers(false);
$this->assertFalse(Log::engine('stdout'));
$this->assertFalse(Log::engine('stderr'));
}
/**
* Log requests to Elastic Search.
*
* @param Request|array $context The context of the request made.
* @return void
*/
protected function _log($context)
{
if (!$this->logQueries) {
return;
}
if (!isset($this->_logger)) {
$this->_logger = Log::engine('elasticsearch') ?: new ElasticaLog();
}
if ($context instanceof Request) {
$data = $context->toArray();
} else {
$data = ['message' => $context];
}
$logData = ['method' => $data['method'], 'path' => $data['path'], 'data' => $data['data']];
$data = json_encode($logData, JSON_PRETTY_PRINT);
$loggedQuery = new LoggedQuery();
$loggedQuery->query = $data;
if ($this->_logger instanceof \Psr\Log\LoggerInterface) {
$this->_logger->log('debug', $loggedQuery);
} else {
$this->_logger->log($loggedQuery);
}
}
/**
* testPassingScopeToEngine method
*/
public function testPassingScopeToEngine()
{
Configure::write('App.namespace', 'TestApp');
Log::reset();
Log::config('scope_test', ['engine' => 'TestApp', 'types' => array('notice', 'info', 'debug'), 'scopes' => array('foo', 'bar')]);
$engine = Log::engine('scope_test');
$this->assertNull($engine->passedScope);
Log::write('debug', 'test message', 'foo');
$this->assertEquals(['scope' => ['foo']], $engine->passedScope);
Log::write('debug', 'test message', ['foo', 'bar']);
$this->assertEquals(['scope' => ['foo', 'bar']], $engine->passedScope);
$result = Log::write('debug', 'test message');
$this->assertFalse($result);
}
