docs: public void processLocalTransactionStartedEvent(Object handle) throws ResourceException {
  
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
  
          if (isTraceOn) 
          {
              if (tc.isEntryEnabled()) 
                  Tr.entry(this, tc, "processLocalTransactionStartedEvent", handle);
  
              if (tc.isDebugEnabled()) 
              { 
                  String cId = null;
                  try {
                      cId = mcf.getCorrelator(this); 
                  } catch (SQLException x) {
                      // will just log the exception here and ignore it since its in trace
                      Tr.debug(this, tc, "got an exception trying to get the correlator in commit, exception is: ", x);
                  }
  
                  if (cId != null) {
                      StringBuffer stbuf = new StringBuffer(200);
                      stbuf.append("Correlator: DB2, ID: ");
                      stbuf.append(cId);
                      if (xares != null) {
                          stbuf.append(" Transaction : ");
                          stbuf.append(xares);
                      }
                      stbuf.append(" BEGIN");
  
                      Tr.debug(this, tc, stbuf.toString());
                  }
              } 
          } 
  
          // An application level local transaction has been requested started
  
          //The isValid method returns an exception if it is not valid.  This allows the
          // WSStateManager to create a more detailed message than this class could.
  
          ResourceException re = stateMgr.isValid(WSStateManager.LT_BEGIN);
          if (re == null) {
              if (currentAutoCommit) {
                  try {
                      if (isTraceOn && tc.isDebugEnabled()) 
                          Tr.debug(this, tc, "current autocommit is true, set to false");
                      setAutoCommit(false);
                  } catch (SQLException sqle) {
                      FFDCFilter.processException(sqle, getClass().getName() + ".processLocalTransactionStartedEvent",
                                                  "550", this);
                      throw new DataStoreAdapterException("DSA_ERROR", sqle, getClass());
                  }
              }
              // Already validated the state so just set it. 
              stateMgr.transtate = WSStateManager.LOCAL_TRANSACTION_ACTIVE;
          } else {
              throw re;
          }
  
          // Fill in the ConnectionEvent only if needed. 
          connEvent.recycle(ConnectionEvent.LOCAL_TRANSACTION_STARTED, null, handle);
  
          if (isTraceOn && tc.isEventEnabled())
              Tr.event(this, tc, 
                       "Firing LOCAL TRANSACTION STARTED event for: " + handle, this);
  
          //Notification of the eventListeners must happen after the state change because if the statechange
          // is illegal, we need to throw an exception.  If this exception occurs, we do not want to
          // notify the cm of the tx started because we are not allowing it to start.
          // loop through the listeners
          for (int i = 0; i < numListeners; i++) {
              // send Local Transaction Started event to the current listener
              ivEventListeners[i].localTransactionStarted(connEvent); 
          }
  
          // Replace ConnectionEvent caching with a single reusable instance per
          // ManagedConnection. 
  
          if (isTraceOn && tc.isEntryEnabled()) 
          {
              Tr.exit(this, tc, "processLocalTransactionStartedEvent", handle);
          }
  
      }