Returns the LogFileHeader for the currently active log file.

@return The LogFileHeader for the currently active log file.

@exception InternalLogException An unexpected error has occured.
180726
LogFileHeader logFileHeader() throws InternalLogException
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "logFileHeader", this);

        // Check that the file is actually open
        if (_activeFile == null)
        {
            if (tc.isEntryEnabled())
                Tr.exit(tc, "logFileHeader", "InternalLogException");
            throw new InternalLogException(null);
        }

        final LogFileHeader logFileHeader = _activeFile.logFileHeader();

        if (tc.isEntryEnabled())
            Tr.exit(tc, "logFileHeader", logFileHeader);
        return logFileHeader;
    }
404988
private void keypointInternal() throws InternalLogException
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "keypointInternal");

        try
        {
            //  _activeFile is in KEYPOINTING state, other file is in ACTIVE state

            force();

            // _activeFile is in KEYPOINTING state, other file is in ACTIVE state

            _activeFile.keypointComplete();

            // _activeFile is in ACTIVE(time2) state, other file is in ACTIVE(time1) (time2 later than time1)

            if (_activeFile == _file1)
            {
                _file2.becomeInactive();
            }
            else
            {
                _file1.becomeInactive();
            }
        } catch (InternalLogException exc)
        {
            FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypointInternal", "952", this);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "keypointInternal", exc);
            throw exc;
        } catch (Throwable exc)
        {
            FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypointInternal", "958", this);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "keypointInternal", "InternalLogException");
            throw new InternalLogException(exc);
        }

        // _activeFile is in ACTIVE state, other file is in INACTIVE state

        if (tc.isEntryEnabled())
            Tr.exit(tc, "keypointInternal");
    }
813807
public String header() {
		StringBuilder output = new StringBuilder();
		output.append("GeoPackage File: " + geoPackage.getPath());
		output.append("\nGeoPackage Name: " + geoPackage.getName());
		return output.toString();
	}
804937
protected function getLogFileName ()
    {
        if (! $this->notification->getBillingAgreement()->isSetAmazonBillingAgreementId()) {
            throw new InvalidArgumentException("BillingAgreementId is NULL");
        }
        
        return $this->notification->getBillingAgreement()->getAmazonBillingAgreementId() .
                 "_BillingAgreementNotification.txt";
    }
1172510
private String getLogRequestIdentifier() {
        if (logIdentifier == null) {
            logIdentifier = String.format("%s-%s %s %s", Integer.toHexString(hashCode()),
                    numberOfRetries, connection.getRequestMethod(), connection.getURL());
        }
        return logIdentifier;
    }
1152650
static String getLogHeader(Map<String, String> config) {
        StringBuilder builder = new StringBuilder(512);

        String productInfo = config.get("websphere.product.info");
        if (productInfo != null) {
            builder.append("product = ").append(productInfo).append(LoggingConstants.nl);
        }

        String installDir = config.get("wlp.install.dir");
        if (installDir != null) {
            builder.append("wlp.install.dir = ").append(installDir).append(LoggingConstants.nl);
        }

        String serverConfigDir = config.get("server.config.dir");
        if (serverConfigDir != null && !"true".equals(config.get("wlp.user.dir.isDefault"))) {
            builder.append("server.config.dir = ").append(serverConfigDir).append(LoggingConstants.nl);
        }

        String serverOutputDir = config.get("server.output.dir");
        if (serverOutputDir != null && !serverOutputDir.equals(serverConfigDir)) {
            builder.append("server.output.dir = ").append(serverOutputDir).append(LoggingConstants.nl);
        }

        builder.append("java.home = ").append(System.getProperty("java.home")).append(LoggingConstants.nl);
        builder.append("java.version = ").append(System.getProperty("java.version")).append(LoggingConstants.nl);
        builder.append("java.runtime = ").append(System.getProperty("java.runtime.name")).append(" (").append(System.getProperty("java.runtime.version")).append(')').append(LoggingConstants.nl);

        builder.append("os = ").append(System.getProperty("os.name")).append(" (").append(System.getProperty("os.version")).append("; ").append(System.getProperty("os.arch")).append(") (").append(Locale.getDefault()).append(")").append(LoggingConstants.nl);

        // avoid the initialization overhead retrieving the RuntimeMXBean. Not guaranteed to work on all platforms, so fallback as appropriate
        builder.append("process = ");
        String pid = System.getProperty("sun.java.launcher.pid");

        if (pid != null) {
            try {
                String ip = InetAddress.getLocalHost().getHostAddress();
                builder.append(pid).append('@').append(ip);
            } catch (Exception e) {
                pid = null;
            }
        }
        if (pid == null) {
            builder.append(ManagementFactory.getRuntimeMXBean().getName());
        }
        builder.append(LoggingConstants.nl);

        return builder.toString();
    }
1121246
protected long writeHeader(java.io.RandomAccessFile logFile)
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this,
                        cclass,
                        "writeHeader",
                        new Object[] { logFile, new Integer(instanceVersion), new Byte(sectorByte),
                                      new Long(startByteAddress), new Long(fileSize) }
                            );

        ObjectManagerByteArrayOutputStream logHeaderStream = new ObjectManagerByteArrayOutputStream(headerLength);
        java.io.DataOutputStream logHeader = new java.io.DataOutputStream(logHeaderStream);

        // Create the data in the log headerBuffer.
        try {
            logHeader.writeByte(0); // Skip over sector byte, for saving sector bits.
            logHeader.writeInt(instanceVersion);
            logHeader.writeByte(sectorByte); // Byte [5].
            logHeader.writeChars(signature);
            logHeader.writeLong(startByteAddress);
            logHeader.writeLong(fileSize);
            logHeader.writeLong(++headerSequence);
            headerWriteTime = System.currentTimeMillis();
            logHeader.writeLong(headerWriteTime);

        } catch (java.io.IOException exception) {
            // No FFDC Code Needed.
            ObjectManager.ffdc.processException(this, cclass, "writeHeader", exception, "1:265:1.8");

            if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                trace.exit(this,
                           cclass,
                           "writeHeader",
                           exception);
            throw new PermanentIOException(this,
                                           exception);
        } // catch java.io.IOException.

        long filePosition = 0;
        byte[] headerBuffer = logHeaderStream.getBuffer();
        // Set the sector bits in the header to be consistent with the sector bits starting 
        // at the start byte address. This is not much use for validating the header has been
        // written completely because we may rewrite it several times without changing the
        // sector bits, however it does help check that the file is a valid log file.
        // Since we only have data in the first sector, in is only really necessary
        // for the first sector to be written successfully. 
        FileLogOutput.setSectorBits(headerBuffer, 0, sectorByte);

        try {
            logFile.seek(0); // Start writing at the head of the file.
            // Write two LogHeaders.
            for (int i = 0; i < 2; i++) {
                logFile.write(headerBuffer,
                              0,
                              headerLength);
                filePosition = filePosition + headerLength;
            } // for 2 log headers.

        } catch (java.io.IOException exception) {
            // No FFDC Code Needed.
            ObjectManager.ffdc.processException(this, cclass, "writeHeader", exception, "1:298:1.8");

            if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                trace.exit(this,
                           cclass,
                           "writeHeader",
                           exception);
            throw new PermanentIOException(this,
                                           exception);
        } // catch java.io.IOException.

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       "writeHeader",
                       new Object[] { new Long(filePosition), new Long(headerSequence), new java.util.Date(headerWriteTime) });
        return filePosition;
    }
670685
private String getLogFolderPath() {

        String path = null;
        if (OpenCms.getRunLevel() >= OpenCms.RUNLEVEL_3_SHELL_ACCESS) {
            path = new File(OpenCms.getSystemInfo().getLogFileRfsPath()).getParent();
            // making sure the path ends with the file separator CHAR
            if ((path != null) && !path.endsWith(File.separator)) {
                path += File.separator;
            }

        }
        return path;
    }
1211542
def log_file(self):
        
        log_file = self.get('log')
        if not log_file:
            log_file = '%s.log' % (self.name)
            self.set('log', log_file)
        return os.path.join(self.initial_dir, self.get('log'))
912550
public String getHeader(String header) {
        if (headers == null) {
            return null;
        }
        return headers.get(header);
    }
887126
public function getHeader()
    {
        if ($this->hasHeader) {
            return $this->header;
        }

        $this->updateConversion();

        if (!$this->getFilePath()) {
            return $this->header;
        }

        $detectorException = null;

        try {
            $header = $this->detector->header(
                $this->firstLines(),
                $this->getSeparator(),
                $this->getDelimiter()
            );
        } catch (DetectionFailedException $detectorException) {
            $header = [];
        }

        $this->headerWasDetected = $header && !$this->isNumericHeader($header);


        if ($this->headerWasDetected) {
            $this->setHeader($header);
            return $this->header;
        }

        // If the header could not be detected, check for encoding errors
        // These will be thrown also if the header is not forced
        $this->getCharsetGuard()->forceCharset($this->firstLinesRaw(), $this->convertFrom);

        // If we can get here the charsetGuard did not throw an exception
        if ($detectorException) {
            throw $detectorException;
        }

        $this->setHeader([]);

        return $this->header;
    }
896633
protected String internalExecute() {
		getLog().info(Messages.AbstractDocumentationMojo_1);
		final Map<File, File> files = getFiles();
		getLog().info(MessageFormat.format(Messages.AbstractDocumentationMojo_2, files.size()));
		return internalExecute(files);
	}
1293796
public List<String> getHeader() {
		if (false == config.containsHeader) {
			throw new IllegalStateException("No header available - header parsing is disabled");
		}
		if (lineNo == 0) {
			throw new IllegalStateException("No header available - call nextRow() first");
		}
		return header.fields;
	}
516099
private function _getLogFileName()
    {
        static $logFileName = null;
        if (null == $logFileName) {
            $logFileName = $this->getUserHome().self::DEFAULT_LOG;
        }
        return $logFileName;
    }
1160613
private File getLogsDirectory() {
        if (logsDirectory != null) {
            return logsDirectory;
        }
        logsDirectory = new File(SeLionGridConstants.LOGS_DIR);

        if (!logsDirectory.exists()) {
            logsDirectory.mkdirs();
        }

        return logsDirectory;
    }
1075617
public String getHeader(String name)
    {
        HeaderField f = getHeaderField(name);
        if (f != null)
        {
            return f.getStringValue();
        }
        else
        {
            return null;
        }
    }
1166683
public function getCurrentLogFilePath()
    {
        $rotateTimeMark = "";
        if ($this->rotateTimeFormat !== null) {
            $rotateTimeMark .= "-" . date($this->rotateTimeFormat);
        }

        if (is_callable($this->prefix)) {
            $prefix = call_user_func_array($this->prefix, []);
            // not check prefix here, let user ensure this correctness
        } else {
            $prefix = $this->prefix;
        }
        return $this->targetLogDir . '/log' . (empty($this->prefix) ? '' : "-" . $prefix) . $rotateTimeMark . '.log';
    }