Log the given array of measure objects in some readable way.

@param measures The array of measures.
@param log A {@link Logger} which will be used for output.
966636
public static void logMeasures(HLAMeasure[] measures, final Logger log) {

        log.info("\nAvailable measures are:");
        log.info("======================");

        for (HLAMeasure currMeasure : measures) {

            log.info(" - " + currMeasure.getSonarName());
        }

        LogHelper.moo(log);
    }
1086987
@SuppressLint("InvalidAccessToGuardedField")
  private void logStats() {
    if (FLog.isLoggable(FLog.VERBOSE)) {
      FLog.v(
          TAG,
          "Used = (%d, %d); Free = (%d, %d)",
          mUsed.mCount,
          mUsed.mNumBytes,
          mFree.mCount,
          mFree.mNumBytes);
    }
  }
1355400
private void log(@NonNull Logger log, @NonNull Throwable t, String msg) {
        log.f(msg + ". Error calling services. " + t.getLocalizedMessage(), t);
    }
1326598
static public void logResponseDetails(HttpResponse response, SFLogger logger)
  {
    if (response == null)
    {
      logger.error("null response");
      return;
    }

    // log the response
    if (response.getStatusLine() != null)
    {
      logger.error("Response status line reason: {}",
                   response.getStatusLine().getReasonPhrase());
    }

    // log each header from response
    Header[] headers = response.getAllHeaders();
    if (headers != null)
    {
      for (Header header : headers)
      {
        logger.error("Header name: {}, value: {}",
                     header.getName(), header.getValue());
      }
    }

    // log response
    if (response.getEntity() != null)
    {
      try
      {
        StringWriter writer = new StringWriter();
        BufferedReader bufferedReader = new BufferedReader(
            new InputStreamReader((response.getEntity().getContent())));
        IOUtils.copy(bufferedReader, writer);
        logger.error("Response content: {}", writer.toString());
      }
      catch (IOException ex)
      {
        logger.error("Failed to read content due to exception: "
                     + "{}", ex.getMessage());
      }
    }
  }
87068
public void setLoggingConfigurations(java.util.Collection<LoggingConfiguration> loggingConfigurations) {
        if (loggingConfigurations == null) {
            this.loggingConfigurations = null;
            return;
        }

        this.loggingConfigurations = new java.util.ArrayList<LoggingConfiguration>(loggingConfigurations);
    }
1130227
public static <T> void initialize(final Log log, final List<Filter<T>> filters) {

        // Check sanity
        Validate.notNull(log, "log");
        Validate.notNull(filters, "filters");

        for (Filter<T> current : filters) {
            current.initialize(log);
        }
    }
940157
public static void log(LogLevel logLevel, String message, String... values) {
        log(logLevel, LOCAL_CLASS, message, values);
    }
697696
public synchronized void writeLog(String log) throws IOException {
		if (mFile.length() < mFileMaxSize) {
			writeLogToFile(log, mFile, true);
		} else {
			rotateLogFiles();
			createNewFile();
			writeLogToFile(log, mFile, false);
		}
	}
1152185
@Override
    protected void log(final String msg) {
        if (config.getLogLevel().equals(LogLevel.DEBUG)) {
            logger.debug(msg);
        } else if (config.getLogLevel().equals(LogLevel.TRACE)) {
            logger.trace(msg);
        } else if (config.getLogLevel().equals(LogLevel.INFO)) {
            logger.info(msg);
        } else if (config.getLogLevel().equals(LogLevel.WARN)) {
            logger.warn(msg);
        } else if (config.getLogLevel().equals(LogLevel.ERROR)) {
            logger.error(msg);
        }
    }
1258359
synchronized void record(TagContext tags, MeasureMapInternal stats, Timestamp timestamp) {
    Iterator<Measurement> iterator = stats.iterator();
    Map<String, AttachmentValue> attachments = stats.getAttachments();
    while (iterator.hasNext()) {
      Measurement measurement = iterator.next();
      Measure measure = measurement.getMeasure();
      if (!measure.equals(registeredMeasures.get(measure.getName()))) {
        // unregistered measures will be ignored.
        continue;
      }
      Collection<MutableViewData> viewDataCollection = mutableMap.get(measure.getName());
      for (MutableViewData viewData : viewDataCollection) {
        viewData.record(
            tags, RecordUtils.getDoubleValueFromMeasurement(measurement), timestamp, attachments);
      }
    }
  }
1275176
public void tryAddLogToBatch(TelemetryData log)
  {
    try
    {
      addLogToBatch(log);
    }
    catch (IOException ex)
    {
      logger.debug("Exception encountered while sending metrics to telemetry endpoint.", ex);
    }
  }
745504
public void log(Logger targetLogger)
    {
        Object[] argumentArray = getArgumentArray();
        if (getArgumentArray() == null) {
            log(targetLogger, getLevel(), getMarker(), getMessage(), getThrowable());
        } else {
            if (getThrowable() != null) {
                argumentArray = ArrayUtils.add(getArgumentArray(), getThrowable());
            }

            log(targetLogger, getLevel(), getMarker(), getMessage(), argumentArray);
        }
    }
201276
public void setLog( Log log )
    {
        this.mavenLogger = log;
        
        //Match the log level of the Java logger with that set in the Maven logger 
        if ( log.isDebugEnabled() ) 
        {
            javaLogger.setLevel( Level.FINE );
        } 
        else if ( log.isInfoEnabled() ) 
        {
            javaLogger.setLevel( Level.INFO );
        } 
        else if ( log.isWarnEnabled() ) 
        {
            javaLogger.setLevel( Level.WARNING );
        } 
        else 
        {
            javaLogger.setLevel( Level.SEVERE );
        }
    }
785462
public static void log(Logger logger, ILoggingEvent event)
    {
        ((ch.qos.logback.classic.Logger) logger).callAppenders(event);
    }
999736
public static void logLoadedServices(Logger log, Class<?> type, List<?> services)
    {
        log.info("Loaded [" + services.size() + "] " + type.getName() + " [" + NEWLINE
                    + joinTypeNames(new ArrayList<>(services)) + "]");
    }
89996
public static void setLogStdOut(boolean log)
    {
        if (log)
        {
            if (!(System.out instanceof LogStream))
                System.setOut(new LogStream.STDOUT());
        }
        else
            System.setOut(STDOUT_STREAM);
    }
225209
public synchronized void log(String formattedLog)
    {
        if (_reopen || _out==null)
        {
            stop();
            start();
        }
        try
        {
            _buffer.write(formattedLog);
            _buffer.write(StringUtil.__LINE_SEPARATOR);
            if (_flushOn || _buffer.size()>_bufferSize)
            {
                _buffer.writeTo(_out);
                _buffer.resetWriter();
                _out.flush();
            }
        }
        catch(IOException e){e.printStackTrace();}
    }