Writes the record down to the log of the implementing handler

@param  $record[]
@return void
348965
protected function write(array $record) {

        if (!$this->initialized) {
            $this->initialize();
        }
        
        // create a cassandra timestamp object
        $time = new Timestamp($record['datetime']->format('U'));
              
        // now insert the data to cassandra
        $this->cassandraConnection->execute(
            new SimpleStatement("INSERT INTO ".$this->table." (channel, level, message, time) VALUES (?, ? , ?, ?)"),
            new ExecutionOptions(array('arguments' => array($record['channel'],$record['level'],$record['message'],$time )))
        );

    }
886879
protected function write(array $record) {
        $context = '';
        if (isset($record['context']) && is_array($record['context']) && (count($record['context']) > 0)) {
            $flattenedContext = [];
            foreach($record['context'] as $key => $value) {
                if (is_array($value)) {
                    continue;
                }

                $flattenedContext[] = "$key = $value";
            }

            $context = implode(", ", $flattenedContext);
        }

        $this->logger->log($record['channel'], $record['level_name'], $record['message'], $context);
    }
1021604
public void write(WARCWritable record) throws IOException {
        if (record.getRecord() != null) write(record.getRecord());
    }
1079630
protected function write(array $record)
	{
		if (!$this->productionMode) {
			return;
		}
		$logDirectory = \Tracy\Debugger::$logDirectory;
		$snooze = @strtotime('15 minutes') - time(); // @ timezone may not be set
		if (@filemtime($logDirectory . '/slack-notification-sent') + $snooze < time() // @ file may not exist
			&& @file_put_contents($logDirectory . '/slack-notification-sent', 'sent') // @ file may not be writable
		) {
			parent::write($record);
		}
	}
629887
protected void writeLogRecord(LogRecord logRecord)
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "writeLogRecord", logRecord);

        _activeFile.writeLogRecord(logRecord);

        if (tc.isEntryEnabled())
            Tr.exit(tc, "writeLogRecord");
    }
656087
protected function processRecord(Record $record)
    {

        foreach ($this->processors as $processor) {
            if ($this->isInstanceOf($processor, ProcessorInterface::class)) {
                $processor->processRecord($record);
            } else {
                call_user_func($processor, $record);
            }
        }
    }
796852
protected static function delete($record) {
        global $DB;

        core_tag_tag::delete_instances($record->component, $record->itemtype);

        $DB->delete_records('tag_area',
                array('itemtype' => $record->itemtype,
                    'component' => $record->component));

        // Reset cache.
        cache::make('core', 'tags')->delete('tag_area');
    }
920704
protected function write(array $record)
    {
        if (!$this->isBatchHandling) {
            $this->contentBuffer = $record['formatted'];
            $this->publishContent();
        }
        else {
            $this->contentBuffer = $record['formatted'] . $this->contentBuffer;
        }
    }
1373458
public void publish(LogRecord record)
  {
    if (! isLoggable(record))
      return;
    
    int level = getLevel().intValue();

    for (int i = 0; i < _handlers.length; i++) {
      Handler handler = _handlers[i];

      if (level <= handler.getLevel().intValue())
        handler.publish(record);
    }
  }
883355
public void write(Object[] record) throws IOException, DbaseFileException {

		if (record.length != header.getNumFields()) {
			throw new DbaseFileException("Wrong number of fields "
					+ record.length + " expected " + header.getNumFields());
		}

		buffer.position(0);

		// put the 'not-deleted' marker
		buffer.put((byte) ' ');

		for (int i = 0; i < header.getNumFields(); i++) {
			String fieldString = fieldString(record[i], i);
			if (header.getFieldLength(i) != fieldString
					.getBytes(charset.name()).length) {
				buffer.put(new byte[header.getFieldLength(i)]);
			} else {
				buffer.put(fieldString.getBytes(charset.name()));
			}

		}

		write();
	}
787871
public void publish(LogRecord record)
  {
    if (! isLoggable(record))
      return;

    if (_handler != null)
      _handler.publish(record);
  }
113388
public function handle(array $record)
    {
        if (!$this->isHandling($record)) {
            return false;
        }

        if (class_exists('Drips\Debugbar\Debugbar')) {
            $debugbar = Debugbar::getInstance();
            if (!$debugbar->hasTab('logger')) {
                $debugbar->registerTab('logger', 'Logs', '<style>' . file_get_contents(__DIR__ . '/style.css') . '</style>');
            }
            $color = $this->logLevels[$record['level']];
            $channel = $record['channel'];
            $level = $record['level_name'];
            $message = $record['message'];
            $log_message = "
            <code class='drips-logger-record' style='color: $color'>
                <table>
                    <tr>
                        <td valign='top'><span class='debug-badge debug-channel'>$channel</span></td>
                        <td valign='top'><strong class='debug-badge' style='background-color: $color'>$level</strong></td>
                        <td valign='top' style='color: $color'>$message</td>
                    </tr>
                </table>
            </code>
           ";
            $debugbar->appendTab('logger', $log_message);
        }

        return false === $this->bubble;
    }
763057
@Override
  public void write(byte[] record) throws IOException {
    Preconditions.checkNotNull(record);

    byte[] toWrite = record;
    if (this.recordDelimiter.isPresent()) {
      toWrite = Arrays.copyOf(record, record.length + 1);
      toWrite[toWrite.length - 1] = this.recordDelimiter.get();
    }
    if (this.prependSize) {
      long recordSize = toWrite.length;
      ByteBuffer buf = ByteBuffer.allocate(Longs.BYTES);
      buf.putLong(recordSize);
      toWrite = ArrayUtils.addAll(buf.array(), toWrite);
    }
    this.stagingFileOutputStream.write(toWrite);
    this.bytesWritten += toWrite.length;
    this.recordsWritten++;
  }
1261835
public function handle(Collection $record)
    {
        $stringMessage = $this->formatter->format($record) . PHP_EOL;
        
        return (boolean) $this->writeStream($stringMessage);
    }
864773
protected function write(array $record)
    {
        $this->connectIfNotConnected();
        $data = $this->generateDataStream($record);
        $this->writeToSocket($data);
    }
805789
protected function __save()
    {
        foreach($this->records as $record)
        {
            $content = $this->getLogString($record);
            if($this->length > 0)
            {
                $content = mb_substr($content, 0, $this->length) . '...';
            }
            echo $content, PHP_EOL;
        }
    }
327235
public function append($log)
    {
        if ($this->_lazy) {
            $context = $this->_context;

            $context->logs[] = $this->_format($log);
        } else {
            $this->_write($this->_format($log));
        }
    }