This is called by the EJB container server code to write a
ejb method callback entry record to the trace log, if enabled.
430231
public static void traceEJBCallEntry(String methodDesc)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
            StringBuffer sbuf = new StringBuffer();

            sbuf
                            .append(BeanLifeCycle_EJBCallEntry_Type_Str).append(DataDelimiter)
                            .append(BeanLifeCycle_EJBCallEntry_Type).append(DataDelimiter)
                            .append(methodDesc);

            Tr.debug(tc, sbuf.toString());
        }
    }
1191709
public void asynchLog(final AuditTrailEvent e, final AuditTrailCallback cb) {
        CommandCallback<BatchInsertIntoAutoTrail.Command> callback = new CommandCallback<BatchInsertIntoAutoTrail.Command>() {
            @Override
            public void commandCompleted() {
                cb.done();
            }

            @Override
            public void unhandledException(Exception e) {
                cb.error(e);
            }
        };
        doLog(e, false, callback);
    }
287846
public void trace(Object message, Throwable t) {
        doLog(Level.TRACE, FQCN, message, null, t);
    }
34351
public void trace(final Throwable t, final String message, final Object ... args)
    {
        if (wrappedLogger.isTraceEnabled()) {
            wrappedLogger.trace(String.format(message, args), t);
        }
    }
92103
function (when, methodName, record) {
            var callbacks = registry[when][methodName]
            for (var i = 0, l = callbacks.length; i < l; i++) {
                callbacks[i].call(this, record)
            }
        }
157883
private void traceJndiBegin(String methodname, Object... objs) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            String providerURL = "UNKNOWN";
            try {
                providerURL = (String) getEnvironment().get(Context.PROVIDER_URL);
            } catch (NamingException ne) {
                /* Ignore. */
            }
            Tr.debug(tc, JNDI_CALL + methodname + " [" + providerURL + "]", objs);
        }
    }
846024
protected void writeLogging(Definition def, Writer out, int indent, String level, String content, String... params)
         throws IOException
   {
      writeIndent(out, indent);
      if (def.isSupportJbossLogging())
      {
         out.write("log.trace");
         int size = params.length;
         if (size > 0)
            out.write("f");
         out.write("(\"" + content + "(");
         for (int i = 0; i < size; i++)
         {
            out.write("%s");
            if (i < size - 1)
               out.write(", ");
         }
         out.write(")\"");
         for (int i = 0; i < size; i++)
         {
            out.write(", ");
            out.write(params[i]);
         }
         out.write(");");
      }
      else
      {
         out.write("log.finest(\"" + content + "()\");");
      }
      writeEol(out);
   }
1133570
static void generateLogForContentProviderBeginning(SQLiteModelMethod method, MethodSpec.Builder methodBuilder) {
		if (method.getParent().isLogEnabled()) {
			methodBuilder.addStatement("$T.info($S, uri.toString())", Logger.class, "Execute " + method.jql.operationType + " for URI %s");
		}

	}
497530
def emit(self, record):
        
        if not logging.raiseExceptions:
            return

        logger = logging.getLogger(record.name)

        # raise an exception based on the error logging
        if logger.level <= record.levelno:
            err = record.msg[0]
            if not isinstance(err, Exception):
                err = ProjexError(nstr(record.msg))

            # log the traceback info
            data = record.__dict__.copy()
            data['type'] = type(err).__name__
            msg = ERROR_MESSAGE % data
            sys.stderr.write(msg)
            raise err
585129
public void trace(String loggerFqcn, Object message, Object[] params, Throwable t) {
        doLog(Level.TRACE, loggerFqcn, message, params, t);
    }
995197
public void postInvokeForLifecycleInterceptors(LifecycleInterceptorWrapper wrapper,
                                                   int methodId,
                                                   EJSDeployedSupport s) throws RemoteException {
        // NOTE: The implementation of this method is structured after postInvoke.
        // For a detailed explanation of the operations here, see the comments in
        // that method.

        EJBMethodInfoImpl methodInfo = s.methodInfo;

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn) {
            if (TEEJBInvocationInfo.isTraceEnabled())
                TEEJBInvocationInfo.tracePostInvokeBegins(s, wrapper);

            if (tcClntInfo.isDebugEnabled())
                Tr.debug(tcClntInfo, "postInvoke(" + methodInfo.getMethodName() + ")");

            if (tc.isEntryEnabled())
                Tr.entry(tc, "postInvokeForLifecycleInterceptors(" + methodId +
                             ":" + methodInfo.getMethodName() + ")");
        }

        // UOWManager.runUnderUOW may have left cached currentTx invalid; reset
        if (s.resetCurrentTx) {
            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "s.currentTx may be invalid; reset");
            s.currentTx = getCurrentContainerTx();
        }

        s.currentTx.postInvoke(s);

        try {
            boolean isRollbackOnly = uowCtrl.getRollbackOnly(); //d636725
            try {
                if (s.began && s.currentTx.ivPostInvokeContext == null) {
                    s.currentTx.ivPostInvokeContext = s;
                }

                uowCtrl.postInvoke(wrapper.beanId, s.uowCookie, s.exType, methodInfo);
            } catch (CSITransactionRolledbackException ex) {
                // Per preInvokeForLifecycleInterceptors, all exceptions thrown from
                // lifecycle interceptors must not be application exceptions.  This
                // ensures postInvokeRolledbackException will propagate this exception
                // (unless setRollbackOnly was called).  The exception is mapped to
                // prevent application code from seeing internal CSIExceptions.
                postInvokeRolledbackException(s, ex);
            }

            //d636725 start
            // If setRollbackOnly was called in a PostConstruct method of a
            // singleton bean, then we need to throw an
            // EJBTransactionRolledBackException here which will be wrapped
            // in a NoSuchEJBException.
            // Our interpretation of the spec requires that we throw this
            // exception here (as opposed to within the setRollbackOnly
            // method - which is an allowed operation) so that the the
            // NoSuchEJBException will be thrown to the client during
            // postInvoke. This behavior is specific to Singleton beans
            // as Stateful and Stateless beans are not allowed to call
            // setRollbackOnly inside PostConstruct methods - they would
            // receive an IllegalStateException.
            if (methodId == LifecycleInterceptorWrapper.MID_POST_CONSTRUCT &&
                isRollbackOnly) {

                String msg = "setRollbackOnly called from within a singleton post construct method.";
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, msg);
                throw new EJBTransactionRolledbackException(msg);
            }
            //d636725 end
        } finally {
            if (!s.began || s.currentTx.ivPostInvokeContext != null) {
                postInvokePopCallbackContexts(s);
            }

            if (s.ivSecurityCollaborator != null) {
                notifyPostInvoke(s.ivSecurityCollaborator, s, s.securityCookie);
            }

            if (s.currentTx != null && s.began) {
                s.currentTx.releaseResources();
                s.currentTx = null;
            }

            EJBThreadData.svThreadContextAccessor.popContextClassLoaderForUnprivileged(s.oldClassLoader);

            s.ivThreadData.popMethodContext(); // d646139.1, RTC102449

            if (isTraceOn) {
                if (tc.isEntryEnabled())
                    Tr.exit(tc, "postInvokeForLifecycleInterceptors(" + methodId + ":" +
                                methodInfo.getMethodName() + ")" +
                                ((s.ivException != null) ? ("**** throws " + s.ivException) : ""));
            }
        }
    }
256973
private final void _writeCallback(Persistable persistable) throws IOException 
    {
        if (_callbackToItem)
        {
            try
            {
                String className = persistable.getItemClassName();
                AbstractItem item = (AbstractItem) (Class.forName(className).newInstance());
                List<DataSlice> dataSlices = _persistentMessageStore.readDataOnly(persistable);
                if (dataSlices != null)
                {
                    item.restore(dataSlices);
                    item.xmlWriteOn(_writer);
                }
            }
            catch (IOException ioexc)
            {
                // No FFDC code needed
                // as this is fault diagnostic code, and the exception 
                // will be dumped to the output anyway
                _writer.write(ioexc);
                throw ioexc;
            }
            catch (Throwable t)
            {
                // No FFDC code needed
                // as this is fault diagnostic code, and the exception 
                // will be dumped to the output anyway
                _writer.write(t);
            }
        }
    }
1243451
private void setStackTrace(Throwable e) {
        // Convert stack trace to a String
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        e.printStackTrace(pw);
        stackTrace = sw.toString();
        setLineSeparator(getLineSeparatorProperty());
    }
392796
function writeLog(msgs){
    var data = (msgs.length === 1) ? msgs[0] : msgs;
    
    this.config.callback(data);
}
999159
@Around("@annotation(org.treetank.aspects.logging.Logging)")
    public Object advice(ProceedingJoinPoint pjp) throws Throwable {
        final Signature sig = pjp.getSignature();
        final Logger logger = FACTORY.getLogger(sig.getDeclaringTypeName());
        logger.debug(new StringBuilder("Entering ").append(sig.getDeclaringTypeName()).toString());
        final Object returnVal = pjp.proceed();
        logger.debug(new StringBuilder("Exiting ").append(sig.getDeclaringTypeName()).toString());
        return returnVal;
    }
209
public static void setTrace(boolean trace) {
        FallbackLoggerConfiguration.trace.set(trace);
        if (trace) {
            debug.set(true);
        }
    }
579427
public static void entry(TraceComponent tc, String methodName) {
    if(isTracing()) SibTr.entry(tc, methodName);

  }