This method is only allowed in the trace perspective.
@param <E>
@param logTrace The log trace to write.
@throws PerspectiveException
@throws IOException
164128
public <E extends LogEntry> void writeTrace(LogTrace<E> logTrace) throws PerspectiveException, IOException{
		if(logPerspective == LogPerspective.ACTIVITY_PERSPECTIVE)
			throw new PerspectiveException(PerspectiveError.WRITE_TRACE_IN_ACTIVITY_PERSPECTIVE);
		
		prepare();
		if(!headerWritten){
			write(logFormat.getFileHeader());
			headerWritten = true;
		}
		output.write(logFormat.getTraceAsString(logTrace));
	}
17693
public void trace(String format, Object... args) {
        if (!logger.isTraceEnabled())
            return;

        if (instanceofLAL) {
            String formattedMessage = MessageFormatter.arrayFormat(format, args).getMessage();
            ((LocationAwareLogger) logger).log(null, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, args, null);
        } else {
            logger.trace(format, args);
        }
    }
673476
@Override
    public void trace( F0<Throwable> exception )
    {
        if ( compilerLogger.isDebugEnabled() )
        {
            compilerLogger.debug( exception.apply() );
        }
    }
459873
public static void printThreadStackTrace(TraceComponent logger, Thread thread) {
        if (logger.isDebugEnabled()) {
            chTrace.traceThreadStack(logger, thread);
        }
    }
397208
public void trace(String format, Object param1) {
        formatAndLog(LOG_LEVEL_TRACE, format, param1, null);
    }
707344
public void addTrace (String info) {
		if (info == null) throw new IllegalArgumentException("info cannot be null.");
		if (trace == null) trace = new StringBuffer(512);
		trace.append('\n');
		trace.append(info);
	}
1037085
public void trace(String msg) {
        if (logger.isLoggable(Level.FINEST)) {
            log(SELF, Level.FINEST, msg, null);
        }
    }
560461
public final void trace(Object message) {

        if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
            log(SimpleLog.LOG_LEVEL_TRACE, message, null);
        }
    }
1135067
@Trivial
    public void log(TraceComponent logger) {

        Tr.debug(logger, MessageFormat.format("Annotation [ {0} ]", getAnnotationClassName()));

        // Only log the non-defaulted values.
        for (String valueName : this.values.keySet()) {
            AnnotationValueImpl nextValue = getValue(valueName);

            String valueEnumClassName = nextValue.getEnumClassName();
            Object valueValue = nextValue.getObjectValue();
            // works for all value types, e.g., Object, Enumerated (as String), Class, Array

            if (valueEnumClassName != null) {
                Tr.debug(logger,
                         MessageFormat.format("  Value: Name [ {0} ] Enum Type [ {1} ] Value [ {2} ]",
                                              new Object[] { valueName, valueEnumClassName, valueValue }));
            } else {
                Tr.debug(logger, MessageFormat.format("  Value: Name [ {0} ] Value [ {1} ]",
                                                      new Object[] { valueName, valueValue }));
            }
        }
    }
73841
public static void write(LogView logView, String path) throws IOException {
                String xml = xstream.toXML(logView);
                try (BufferedWriter out = new BufferedWriter(new FileWriter(path))) {
                        out.write(xml);
                }
        }
412392
public void trace(Object format, Object... msg) {
		if (logger.isTraceEnabled()) {
			if (format.toString().contains("{")) {
				logger.trace(format.toString(), msg);
			} else {
				logger.trace(format.toString().concat(" ").concat(JKStringUtil.concat(msg)));
			}
		}
	}
502288
public final static void logException(TraceComponent compTc, Throwable t, EJBMethodMetaData m, BeanO bean) {
        //d408351 - only log recursive exceptions if they have not been logged before
        if (hasBeenLogged(t)) {
            return;
        }

        BeanId beanId = null;
        if (bean != null) {
            beanId = bean.getId();
        }

        if (m == null) {
            if (beanId == null) {
                Tr.error(compTc, "NON_APPLICATION_EXCEPTION_CNTR0018E", t);
            } else {
                Tr.error(compTc, "NON_APPLICATION_EXCEPTION_ON_BEAN_CNTR0021E", new Object[] { t, beanId });
            }
        } else {
            String methodName = m.getMethodName();
            if (beanId == null) {
                Tr.error(compTc, "NON_APPLICATION_EXCEPTION_METHOD_CNTR0019E", new Object[] { t, methodName });
            } else {
                Tr.error(compTc, "NON_APPLICATION_EXCEPTION_METHOD_ON_BEAN_CNTR0020E", new Object[] { t, methodName, beanId });
            }

        }

    }
808181
public static void logException(String message, Exception e) {
    logger.log(Level.SEVERE, message, e);
  }
1156207
public void setTraces(java.util.Collection<Trace> traces) {
        if (traces == null) {
            this.traces = null;
            return;
        }

        this.traces = new java.util.ArrayList<Trace>(traces);
    }
499429
public void trace( String format, Object arg )
    {
        if( m_delegate.isTraceEnabled() )
        {
            FormattingTuple tuple = MessageFormatter.format( format, arg );
            m_delegate.trace( tuple.getMessage(), tuple.getThrowable() );
        }
    }
767512
protected void closeLogExc(@Nullable final Closeable closeable) {
		if (closeable == null) {
			return;
		}

		try {
			closeable.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
929833
void log(Level level, String msg, Exception e) {
        if (e != null)
            logger.log(level, msg, e);
    }