Set the writers for SystemOut and SystemErr respectfully

@param sysLogHolder SystemLogHolder object for SystemOut
@param sysErrHolder SystemLogHolder object for SystemErr
772638
public void setWriter(Object sysLogHolder, Object sysErrHolder) {
        this.sysOutHolder = (SystemLogHolder) sysLogHolder;
        this.sysErrHolder = (SystemLogHolder) sysErrHolder;
    }
954581
public static void setLogStdErr(boolean log)
    {
        if (log)
        {
            if (!(System.err instanceof LogStream))
                System.setErr(new LogStream.STDERR());
        }
        else
            System.setErr(STDERR_STREAM);
    }
850073
@Override
    protected void captureSystemStreams() {
        PrintStream sysOut = System.out;
        PrintStream sysErr = System.err;

        PrintStream trSysOut = systemOut.getOriginalStream();
        PrintStream trSysErr = systemErr.getOriginalStream();

        if (sysOut != trSysOut) {
            throw new ConcurrentModificationException("Someone else has reset or cached System.out");
        }
        if (sysErr != trSysErr) {
            throw new ConcurrentModificationException("Someone else has reset or cached System.err");
        }

        super.captureSystemStreams();
    }
1053116
public void setLogDataDirectory(String logDataDirectory) {
    	LogState state = ivLog.setDataDirectory(logDataDirectory);
    	if (state != null) {
    		updateLogConfiguration(state);
    		state.copyTo(ivLog);
    	}
    }
52599
private static void initializeLogger(Logger logger) {

		// Do NOT send any logging information to parent loggers.
		topLogger.setUseParentHandlers(false);

		// Remove any existing handlers.
		for (Handler handler : topLogger.getHandlers()) {
			try {
				topLogger.removeHandler(handler);
			} catch (SecurityException consumed) {
				System.err
						.println("WARNING: missing 'LoggingPermission(\"control\")' permission");
			}
		}

	}
67822
public void init(Props sysProps, Props jobProps, final Logger logger) {
    shouldProxy = sysProps.getBoolean(HadoopSecurityManager.ENABLE_PROXYING, false);
    jobProps.put(HadoopSecurityManager.ENABLE_PROXYING, Boolean.toString(shouldProxy));
    obtainTokens = sysProps.getBoolean(HadoopSecurityManager.OBTAIN_BINARY_TOKEN, false);
    if (shouldProxy) {
      logger.info("Initiating hadoop security manager.");
      try {
        hadoopSecurityManager = HadoopJobUtils.loadHadoopSecurityManager(sysProps, logger);
      } catch (RuntimeException e) {
        e.printStackTrace();
        throw new RuntimeException("Failed to get hadoop security manager!"
            + e.getCause());
      }
    }
  }
625197
@Override
    public void sendMessage(CharArrayWriter message) throws IOException {

        SyslogMessage syslogMessage = new SyslogMessage()
                .withAppName(defaultAppName)
                .withFacility(defaultFacility)
                .withHostname(defaultMessageHostname)
                .withSeverity(defaultSeverity)
                .withMsg(message);

        sendMessage(syslogMessage);
    }
621400
public void setLoggerRepository(final LoggerRepository repository) {
        if (this.repository == null) {
            this.repository = repository;
        } else if (this.repository != repository) {
            throw new IllegalStateException("Repository has been already set");
        }
    }
176304
public static syslog_server delete(nitro_service client, syslog_server resource) throws Exception
	{
		resource.validate("delete");
		return ((syslog_server[]) resource.delete_resource(client))[0];
	}
624288
@Inject
	public void setDocumentParser(SarlDocumentationParser parser) {
		assert parser != null;
		this.parser = parser;
		this.parser.reset();
	}
893176
public static void setLogfile(Class<? extends IRTLogger> loggerClass,
			File outputFile) throws FileNotFoundException
	{
		for (IRTLogger logger : loggers)
		{
			if (logger.getClass() == loggerClass)
			{
				logger.setLogfile(outputFile);
				logger.dump(true); // Write out and close previous
			}
		}

		enable(true);
	}
109741
public void setFileSystemIds(java.util.Collection<String> fileSystemIds) {
        if (fileSystemIds == null) {
            this.fileSystemIds = null;
            return;
        }

        this.fileSystemIds = new java.util.ArrayList<String>(fileSystemIds);
    }
1368953
public void setLoggerRepository(final LoggerRepository repository) {
        Object oldValue = this.repository;
        this.repository = repository;
        firePropertyChange("loggerRepository", oldValue, this.repository);
    }
733770
protected void logResources() throws SystemException {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "logResources", _resourcesLogged);

        if (!_resourcesLogged) {
            for (int i = 0; i < _resourceObjects.size(); i++) {
                final JTAResource resource = _resourceObjects.get(i);

                if (resource.getResourceStatus() == StatefulResource.PREPARED) {
                    recordLog(resource);
                }
            }

            _resourcesLogged = true;
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "logResources");
    }
1250350
@Override
    public final void xmlRequestWriteOnSystemOut() throws IOException
    {
        FormattedWriter writer = new FormattedWriter(new OutputStreamWriter(System.out));
        xmlWriteOn(writer);
        writer.flush();
    }
325491
public static void loggerInit(Level level, boolean isRedirectStdOutErr, String format)
      throws IOException {
    // Set the java util logging format
    setLoggingFormat(format);

    // Configure the root logger and its handlers so that all the
    // derived loggers will inherit the properties
    Logger rootLogger = Logger.getLogger("");
    for (Handler handler : rootLogger.getHandlers()) {
      handler.setLevel(level);
    }

    rootLogger.setLevel(level);

    if (rootLogger.getLevel().intValue() < Level.WARNING.intValue()) {
      // zookeeper logging scares me. if people want this, we can patch to config-drive this
      Logger.getLogger("org.apache.zookeeper").setLevel(Level.WARNING);
    }

    // setting logging for http client to be error level
    System.setProperty(
        "org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
    System.setProperty(
        "org.apache.commons.logging.simplelog.log.httpclient.wire", "ERROR");
    System.setProperty(
        "org.apache.commons.logging.simplelog.log.org.apache.http", "ERROR");
    System.setProperty(
        "org.apache.commons.logging.simplelog.log.org.apache.http.headers", "ERROR");

    if (isRedirectStdOutErr) {

      // Remove ConsoleHandler if present, to avoid StackOverflowError.
      // ConsoleHandler writes to System.err and since we are redirecting
      // System.err to Logger, it results in an infinite loop.
      for (Handler handler : rootLogger.getHandlers()) {
        if (handler instanceof ConsoleHandler) {
          rootLogger.removeHandler(handler);
        }
      }

      // now rebind stdout/stderr to logger
      Logger logger;
      LoggingOutputStream los;

      logger = Logger.getLogger("stdout");
      los = new LoggingOutputStream(logger, StdOutErrLevel.STDOUT);
      System.setOut(new PrintStream(los, true));

      logger = Logger.getLogger("stderr");
      los = new LoggingOutputStream(logger, StdOutErrLevel.STDERR);
      System.setErr(new PrintStream(los, true));
    }
  }
348239
@Override
	public void logrb(Level level, String sourceClass, String sourceMethod, ResourceBundle bundle, String msg,
			Object... params) {
		
		super.logrb(level, sourceClass, sourceMethod, bundle, maskPassword(msg), params);
	}