Logs the occurance of an exception while retrieving the input file.

@param logger
reference to the logger
@param archive
reference to the archive
@param e
reference to the exception
354114
public static void logExceptionRetrieveArchive(final Logger logger,
			final ArchiveDescription archive, final Exception e)
	{

		logger.logException(Level.ERROR, "Exception while accessing archive "
				+ archive.toString(), e);
	}
455586
public void log(Throwable exception) {
		if (exception instanceof CoreException) {
			getILog().log(new Status(IStatus.ERROR, PLUGIN_ID,
					exception.getMessage(),
					exception.getCause()));
		} else if (exception != null) {
			getILog().log(new Status(IStatus.ERROR, PLUGIN_ID,
					exception.getMessage(), exception));
		} else {
			getILog().log(new Status(IStatus.ERROR, PLUGIN_ID,
					"Internal Error", exception));   //$NON-NLS-1$
		}
	}
950973
@Override
	public void error(String msg, Throwable e) {
		LoggerFactory.getLogger(from).error(msg);
	}
891965
public static void log(final Level level, final Throwable exception) {
		String nameOfException = exception.getClass().getName();
		String messageOfException = exception.getMessage();

		if (messageOfException == null || messageOfException.isEmpty()) {
			System.err.println("LOGGER " + level + ": " + nameOfException);
		} else {
			System.err.println("LOGGER " + level + ": " + messageOfException + " (" + nameOfException + ")");
		}
	}
134641
@Override
  public void logException(LogLevel logLevel, Throwable throwable, Class clazz, String methodName) {
    Logger logger = Logger.getLogger(clazz.getName());
    logger.logp(convertToJDK14Level(logLevel), clazz.getName(), "-", throwable.getMessage(), throwable);
  }
627967
public void e(final String msg) {
        logMgr.log(tag, LogLevelConst.ERROR, msg, null);
    }
1191832
public static void logReadTaskOutOfMemoryError(final Logger logger,
			final Task<Diff> task, final OutOfMemoryError e)
	{

		if (task != null) {
			logger.logError(Level.WARN, "Error while reading a task: "
					+ task.toString(), e);
		}
		else {
			logger.logError(Level.WARN,
					"Error while reading an unknown task", e);
		}
	}
210008
protected void logException (final Throwable t, final String msg, final Object[] messageParams) {
		logger.error(msg, messageParams, t);
	}
1106291
public static void logUncaughtExceptions(Logging logger) {
    try {
      Thread.setDefaultUncaughtExceptionHandler((t, e) -> logger.exception(e));
    }
    catch(SecurityException e) {
      logger.warning("Could not set the Default Uncaught Exception Handler", e);
    }
  }
746665
public void addException(Exception e) {
        if (exceptions == null) {
            exceptions = new ArrayList<>();
        }
        exceptions.add(e);
        log.error(e.getMessage(), e);
    }
897280
public static void keeperException(String msg, KeeperException e)
      throws IOException {
    LOG.error(msg, e);
    throw new IOException(msg, e);
  }
1300972
private void log(Level lv, String msg, Throwable e) {
        if (logger.isLoggable(lv)) {
            LogRecord r = new LogRecord(lv, msg);
            r.setThrown(e);

            // find the nearest ancestor that doesn't belong to JDKLogImpl
            for (StackTraceElement frame : new Exception().getStackTrace()) {
                if (!frame.getClassName().equals(THIS_CLASS_NAME)) {
                    r.setSourceClassName(frame.getClassName());
                    r.setSourceMethodName(frame.getMethodName());
                    break;
                }
            }

            logger.log(r);
        }
    }
171622
public static void logException( Logger logger, Throwable t ) {
		logException( logger, Level.FINEST, t );
	}
1288876
public static void logNoMoreArticles(final Logger logger,
			final ArchiveDescription archive)
	{

		logger.logMessage(Level.INFO, "Archive " + archive.toString()
				+ " contains no more articles");
	}
409692
boolean archiveFile(File logFile) {

		FileOutputStream fOut;
		ZipOutputStream zOut;

		// necessary because of possible IOException
		try {
			fOut = new FileOutputStream(logFile.getPath() + ".zip");
			zOut = new ZipOutputStream(fOut);

			FileInputStream fIn = new FileInputStream(logFile);
			BufferedInputStream bIn = new BufferedInputStream(fIn);

			// new ZipEntry to put into the archive
			ZipEntry entry = new ZipEntry(logFile.getCanonicalFile().getName());
			zOut.putNextEntry(entry);

			// create a byte array
			byte[] barray = new byte[1024];
			// byte count variable
			int bytes;

			// read the BufferedInputStream and write it entirely to the archive
			while ((bytes = bIn.read(barray, 0, 1024)) > -1) {
				zOut.write(barray, 0, bytes);
			}

			// clean up
			zOut.flush();
			zOut.close();
			fOut.close();

			return true;

		} catch (IOException ioE) {
			return false;
		}

	}
663714
public static void e(String tag, String msg, Throwable throwable) {
        if (sLevel > LEVEL_ERROR) {
            return;
        }
        Log.e(tag, msg, throwable);
    }
808181
public static void logException(String message, Exception e) {
    logger.log(Level.SEVERE, message, e);
  }