Sets whether trace logging should be enabled.
Enabling trace logging automatically enables debug logging, too.

@param trace Whether trace logging should be enabled or not.
209
public static void setTrace(boolean trace) {
        FallbackLoggerConfiguration.trace.set(trace);
        if (trace) {
            debug.set(true);
        }
    }
1352647
def settrace(self, do_set):
        """"""
        if do_set:
            sys.settrace(self.trace_dispatch)
        else:
            sys.settrace(None)
1228034
protected void debug(String message, Throwable throwable) {
		final Log log = getLog();
		if (log != null)
			log.debug(message, throwable);
	}
28768
public static void trace(Log log, String format, Object... arguments) {
		if (false == log(log, Level.TRACE, null, format, arguments)) {
			log.trace(format, arguments);
		}
	}
204261
public void trace(Object message, Throwable t) {
        differentiatedLog(null, LOGGER_FQCN, LocationAwareLogger.TRACE_INT, message, t);
    }
1037085
public void trace(String msg) {
        if (logger.isLoggable(Level.FINEST)) {
            log(SELF, Level.FINEST, msg, null);
        }
    }
659296
public void trace(String msg, Throwable t) {
        if (!logger.isTraceEnabled())
            return;

        if (instanceofLAL) {
            ((LocationAwareLogger) logger).log(null, fqcn, LocationAwareLogger.TRACE_INT, msg, null, t);
        } else {
            logger.trace(msg, t);
        }
    }
390834
def enable_tracing(self):
        
        _logger.x_debug("entering enable_tracing()")
        # uncomment next line to get debugger tracing info
        #self.dump_tracing_state("before enable_tracing()")
        
        if not self.tracing_enabled and self.execution_started:
            # Restore or set trace function on all existing frames appart from 
            # debugger
            threading.settrace(self._tracer)  # then enable on all threads to come
            for thr in threading.enumerate():
                if thr.ident != self.debugger_thread_ident:  # skip debugger thread
                    a_frame = sys._current_frames()[thr.ident]
                    while a_frame:
                        a_frame.f_trace = self._tracer
                        a_frame = a_frame.f_back
            iksettrace3._set_trace_on(self._tracer, self.debugger_thread_ident)
            self.tracing_enabled = True
        
        #self.dump_tracing_state("after enable_tracing()")
        return self.tracing_enabled
171285
synchronized static TraceSpecification setTraceSpec(String spec) {
        // If logger is used & configured by logger properties, 
        // we're done as far as trace string processing is concerned
        if (WsLogManager.isConfiguredByLoggingProperties()) {
            return null;
        }

        // If the specified string is null, or it is equal to a string,
        // or the sensitive flag has not been toggled,
        // we've already parsed, skip it.
        if ((spec == null || spec.equals(traceString)) && Tr.activeTraceSpec.isSensitiveTraceSuppressed() == suppressSensitiveTrace) {
            return null;
        }

        traceString = spec;

        // Parse the trace specification string, this will gather
        // exceptions that occur for different elements of the string
        TraceSpecification newTs = new TraceSpecification(spec, safeLevelsIndex, suppressSensitiveTrace);
        TraceSpecificationException tex = newTs.getExceptions();

        if (tex != null) {
            do {
                tex.warning(loggingConfig.get() != null);
                tex = tex.getPreviousException();
            } while (tex != null);
        }

        Tr.setTraceSpec(newTs);

        // Return the new/updated TraceSpecification to the caller. The caller can
        // then determine whether or not all elements of the TraceSpecification 
        // were known to the system or not.
        return newTs;
    }
1276304
public static void debug(Logger log, String methodName) {
        if (log.isDebugEnabled())
            log.debug(buildMethodLogString(methodName));
    }
470117
public void trace(final String msg) {
        if (proxy.isTraceEnabled()) {
            if (proxy instanceof LocationAwareLogger) {
                ((LocationAwareLogger) proxy).log(null, FQCN, LocationAwareLogger.TRACE_INT, msg, null, null);
            } else {
                proxy.trace(msg);
            }
        }
    }
520500
public void setTraceIds(java.util.Collection<String> traceIds) {
        if (traceIds == null) {
            this.traceIds = null;
            return;
        }

        this.traceIds = new java.util.ArrayList<String>(traceIds);
    }
645786
public void trace(Object message, Throwable exception) {
    log(Level.TRACE, message, exception);
  }
994475
@Override
    public void setTraceRouter(WsTraceRouter traceRouter) {

        internalTraceRouter.set(traceRouter);

        // Pass the earlierMessages queue to the router.
        // Now that the internalMessageRouter is non-null, this class will
        // NOT add any more messages to the earlierMessages queue.
        // The MessageRouter basically owns the earlierMessages queue
        // from now on.
        if (earlierTraces != null) {
            synchronized (this) {
                if (earlierTraces != null) {
                    traceRouter.setEarlierTraces(earlierTraces);
                }
            }
        } else {
            traceRouter.setEarlierTraces(null);
        }
    }
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);
        }
    }
388656
@Override
    public void trace(String format, Object arg) {
        if (isTraceEnabled()) {
            FormattingTuple ft = MessageFormatter.format(format, arg);
            logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, ft
                    .getMessage(), ft.getThrowable());
        }
    }
899505
public static void printStackTrace(StackTraceElement[] trace, java.io.PrintWriter out) {
        Strand.printStackTrace(trace, out);
    }