from interface LogChute
7514
public void init (RuntimeServices rsvc)
    {
        // if we weren't constructed with a servlet context, try to obtain
        // one via the application context
        if (_sctx == null) {
            // first look for the servlet context directly
            _sctx = (ServletContext)rsvc.getApplicationAttribute("ServletContext");
        }

        // if that didn't work, look for an application
        if (_sctx == null) {
            // first look for an application
            Application app = (Application)
                rsvc.getApplicationAttribute(Application.VELOCITY_ATTR_KEY);
            if (app != null) {
                _sctx = app.getServletContext();
            }
        }

        // if we still don't have one, complain
        if (_sctx == null) {
            rsvc.getLog().warn("ServletContextLogger: servlet context was not supplied. A user " +
                               "of the servlet context logger must call " +
                               "Velocity.setApplicationAttribute(\"ServletContext\", " +
                               "getServletContext()).");
        }
    }
261903
@Override
    public void init(RuntimeServices rs) {
        String name = (String) rs.getProperty(LOGCHUTE_SLF4J_NAME);

        if (name == null) {
            name = DEFAULT_LOG_NAME;
        }
        log = LoggerFactory.getLogger(name);
        log(LogChute.DEBUG_ID, "Slf4jLogChute name is '" + name + "'");
    }
1139293
private Logger createClassLogger(InjectionPoint injectionPoint) {
		return Logger.getLogger(injectionPoint.getMember().getDeclaringClass().getName());
	}
69044
private void printlnInternal(int logLevel, String msg) {
    String tag = logConfiguration.tag;
    String thread = logConfiguration.withThread
        ? logConfiguration.threadFormatter.format(Thread.currentThread())
        : null;
    String stackTrace = logConfiguration.withStackTrace
        ? logConfiguration.stackTraceFormatter.format(
        StackTraceUtil.getCroppedRealStackTrack(new Throwable().getStackTrace(),
            logConfiguration.stackTraceOrigin,
            logConfiguration.stackTraceDepth))
        : null;

    if (logConfiguration.interceptors != null) {
      LogItem log = new LogItem(logLevel, tag, thread, stackTrace, msg);
      for (Interceptor interceptor : logConfiguration.interceptors) {
        log = interceptor.intercept(log);
        if (log == null) {
          // Log is eaten, don't print this log.
          return;
        }

        // Check if the log still healthy.
        if (log.tag == null || log.msg == null) {
          throw new IllegalStateException("Interceptor " + interceptor
              + " should not remove the tag or message of a log,"
              + " if you don't want to print this log,"
              + " just return a null when intercept.");
        }
      }

      // Use fields after interception.
      logLevel = log.level;
      tag = log.tag;
      thread = log.threadInfo;
      stackTrace = log.stackTraceInfo;
      msg = log.msg;
    }

    printer.println(logLevel, tag, logConfiguration.withBorder
        ? logConfiguration.borderFormatter.format(new String[]{thread, stackTrace, msg})
        : ((thread != null ? (thread + SystemCompat.lineSeparator) : "")
        + (stackTrace != null ? (stackTrace + SystemCompat.lineSeparator) : "")
        + msg));
  }
729054
private void logIfEnabled(Level level, Throwable throwable, String format, Object[] arguments){
		this.logIfEnabled(FQCN_SELF, level, throwable, format, arguments);
	}
354380
private void logInfo(@NonNull final Logger log) {
        log.i("App ver. = " + deviceDAO.device().getAppVer());
        log.i("Comapi device ID = " + deviceDAO.device().getDeviceId());
        log.d("Firebase ID = " + deviceDAO.device().getInstanceId());
    }
38084
@Override
  public void logMessage(LogLevel logLevel, String message, Class clazz, String methodName) {
  }
977819
static void createLoggingPropertiesFile(InstanceType type) throws IOException {
        LOGGER.entering(type);

        String installedFile = LOGGING_PROPERTIES_FILE + "." + type.getFriendlyName();
        if (!new File(installedFile).exists()) {

            // Need to change the backward slash to forward, so that logger able to locate path in windows
            String logPath = LOGS_DIR.replace("\\", "/");

            String value = IOUtils.toString(JarSpawner.class.getResourceAsStream(LOGGING_PROPERTIES_FILE_RESOURCE),
                    "UTF-8");
            value = value.concat("\njava.util.logging.FileHandler.pattern=" + logPath + "selion-grid-" + type.getFriendlyName()
                    + "-%g.log");
            FileUtils.writeStringToFile(new File(installedFile), value, "UTF-8");
            LOGGER.fine("Logger file created successfully. Path is " + installedFile);
        }

        LOGGER.exiting();
    }
884645
private void writeInterface(final GeneratorContext context, final TreeLogger logger,
      final BeanHelper bean) {
    final PrintWriter pw = context.tryCreate(logger, bean.getPackage(), bean.getValidatorName());
    if (pw != null) {
      final TreeLogger interfaceLogger = logger.branch(TreeLogger.TRACE,
          "Creating the interface for " + bean.getFullyQualifiedValidatorName());

      final ClassSourceFileComposerFactory factory =
          new ClassSourceFileComposerFactory(bean.getPackage(), bean.getValidatorName());
      factory.addImplementedInterface(
          GwtSpecificValidator.class.getCanonicalName() + " <" + bean.getTypeCanonicalName() + ">");
      factory.addImport(GWT.class.getCanonicalName());
      factory.makeInterface();
      final SourceWriter sw = factory.createSourceWriter(context, pw);

      // static MyValidator INSTANCE = GWT.create(MyValidator.class);
      sw.print("static ");
      sw.print(bean.getValidatorName());
      sw.print(" INSTANCE = GWT.create(");
      sw.print(bean.getValidatorName());
      sw.println(".class);");

      sw.commit(interfaceLogger);
      pw.close();
    }
  }
609141
function Logger (options) {
  if (!(this instanceof Logger)) return new Logger(options);

  options = options || {};

  debug('new logger v%s', pkg.version);

  var router = Router();
  router.on(function (sock, args, cb) {
    debug('logger args.length %s', arguments.length);
    try {
      // "this" is the "socket"
      logger.stream().write(logger.format(sock, args) + "\n");
      cb();
    }
    catch (e) {
      debug('caught an error %s', e);
      console.trace(e);
      cb(e);
    }
  });

  function logger (sock, cb) {
    debug('logger sock', sock, cb.toString());
    router(sock, cb);
  }

  logger.__proto__ = Logger.prototype;

  if (options.stream) {
    logger.stream(options.stream);
  }

  if (options.format) {
    logger.format(options.format);
  }

  return logger;
}
534434
function logClient (logClient) {
    if (defined(logClient)) {
        // validate that log client has required methods
        requireValidLogClient(logClient)
        // set default
        immutable.defaultLogClient = logClient
        // return immutable
        return ImmutableCore
    }
    // return default value
    return immutable.defaultLogClient
}
477476
function Connection(log, firstStreamId, settings) {
  // * initializing the base class
  Flow.call(this, 0);

  // * logging: every method uses the common logger object
  this._log = log.child({ component: 'connection' });

  // * stream management
  this._initializeStreamManagement(firstStreamId);

  // * lifecycle management
  this._initializeLifecycleManagement();

  // * flow control
  this._initializeFlowControl();

  // * settings management
  this._initializeSettingsManagement(settings);

  this._initializeConnectionFlowControl();

  // * multiplexing
  this._initializeMultiplexing();
}
9976
@Override
    protected void logImpl(LogLevel level,Object[] message,Throwable throwable)
    {
        //format log message
        String text=this.formatLogMessage(level,message,throwable);
        
        //print text to system out
        System.out.println(text);
    }
1336021
public void logInfo(String message, Exception exception) {
        if (!(logInfo || globalLog.logInfo))
            return;
	
        if (infoLog != null)
            log(infoLog, "INFO", owner, message, exception);
        else
            log(globalLog.infoLog, "INFO", owner, message, exception);
    }
957046
private static void logSession(final Session session, boolean async, final String activity) {
		final TransportStrategy transportStrategy = TransportStrategy.findStrategyForSession(session);
		final Properties properties = session.getProperties();
		final String sessionDetails = (transportStrategy != null) ? transportStrategy.toString(properties) : properties.toString();
		LOGGER.debug("starting{} {} with {}", async ? " async" : "", activity, sessionDetails);
	}
397641
@Override
    protected void logImpl(LogLevel level,Object[] message,Throwable throwable)
    {
        //get log level
        int levelValue=level.getValue();
        Level jdkLevel=null;
        switch(levelValue)
        {
            case LogLevel.DEBUG_LOG_LEVEL_VALUE:
                jdkLevel=Level.FINEST;
                break;
            case LogLevel.ERROR_LOG_LEVEL_VALUE:
                jdkLevel=Level.SEVERE;
                break;
            case LogLevel.INFO_LOG_LEVEL_VALUE:
            default:
                jdkLevel=Level.FINE;
                break;
        }

        if(jdkLevel!=null)
        {
            //format log message (without exception)
            String text=this.formatLogMessage(level,message,null);

            //log
            this.JDK_LOGGER.log(jdkLevel,text,throwable);
        }
    }
214088
static Object logModule(boolean quiet, boolean verbose) {
    checkArgument(!(quiet && verbose), "quiet and verbose flags cannot be used at the same time!");
    Logger.Level logLevel;
    if (quiet) {
      return null;
    } else if (verbose) {
      logLevel = Logger.Level.FULL;
    } else {
      logLevel = Logger.Level.BASIC;
    }
    return new LogModule(logLevel);
  }