docs: final void commit(EJBKey key, EJBMethodInfoImpl methodInfo)
                      throws CSITransactionRolledbackException
      {
          LocalTransactionCoordinator lCoord = ltcCurrent.getLocalTranCoord();
  
          // If local tx exists; process it.  There must not be a global tx.
  
          if (lCoord != null)
          {
              if (lCoord.isASScoped()) // d130989
              {
                  endASLocalTx(key, methodInfo, lCoord, false); // RTC103197
              }
              // Otherwise, sticky local tx not required so end local tx now.
              else
              {
                  try {
                      // d171555.3.2 Begins
                      //                     int resolver = (((EJBComponentMetaData)methodInfo.getComponentMetaData()).getLocalTranConfigData()).getValueResolver();
                      //
                      //                     // Is this an EJB 2.0 or newer component && the container is responsible for begin / end
                      //                     // of connection specific local transactions (ie. RMLTs)?  We only need to check
                      //                     // resolver because EJB 1.1 beans never have resolver = ContainerAtBoundary.  This
                      //                     // is enforced by a check in BeanMetaData.
                      //
                      //                     if (resolver == LocalTranConfigData.RESOLVER_CONTAINER_AT_BOUNDARY) {  //d135218
                      //
                      //                        // Complete the LTC context so enlisted resources will be committed.
                      //                        // When Container is responsible to automatically begin / end connections,
                      //                        // (i.e. local trancation resolver = containerAtBoundary) the connection
                      //                        // manager enlists each connection as a resource in the local transaction
                      //                        // context.  Enlist causes LocalTransaction.begin to occur on the
                      //                        // connections.  Here we are "completing" the context which causes
                      //                        // LocalTransaction.commit to occur for the enlisted connections.
                      //
                      //                        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                      //                           Tr.event(tc, "Completing LTC cntxt: " + System.identityHashCode(lCoord));
                      //                        }
                      //                        lCoord.complete(LocalTransactionCoordinator.EndModeCommit);
                      //                        // d165585 Begins
                      //                        if( TETxLifeCycleInfo.isTraceEnabled() )              // PQ74774
                      //                        {
                      //                            if( lCoord != null )
                      //                            {
                      //                                TETxLifeCycleInfo.traceLocalTxCommit( "" + System.identityHashCode( lCoord ), "Commit Local Tx - complete" );
                      //                            }
                      //                        }
                      //                        // d165585 Ends
                      //
                      //                     } else {
                      //
                      //                        // Cleanup the LTC context so resources enlisted for cleanup will catch any
                      //                        // application errors.  When resolver = application, the application code is
                      //                        // responsible to do begin / end of the connections.  In this case the
                      //                        // connection manager enlists the connections for cleanup in the local
                      //                        // transaction context.  They are delisted iff the application remembers to
                      //                        // end them (ie. commit or rollback).  Here we end the context with
                      //                        // "cleanup" which will cause commit or rollback of any remaining connections
                      //                        // (ie. application forgot to finish them), based on the bean's local
                      //                        // transaction configuration setting for unresolved-action (ie. COMMIT or
                      //                        // ROLLBACK).
                      //
                      //                        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                      //                           Tr.event(tc, "Ending LTC cntxt: " + System.identityHashCode(lCoord));
                      //                        }
                      //                        lCoord.cleanup();
                      //                        // d165585 Begins
                      //                        if( TETxLifeCycleInfo.isTraceEnabled() )              // PQ74774
                      //                        {
                      //                            if( lCoord != null )
                      //                            {
                      //                                TETxLifeCycleInfo.traceLocalTxCommit( "" + System.identityHashCode( lCoord ), "Commit Local Tx - cleanup" );
                      //                            }
                      //                        }
                      //                        // d165585 Ends
                      //                     }
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                          Tr.event(tc, "Completing LTC cntxt: tid=" +
                                       Integer.toHexString(lCoord.hashCode()) + "(LTC)");
  
                      lCoord.end(LocalTransactionCoordinator.EndModeCommit); // d171555.3.2
  
                      if (TraceComponent.isAnyTracingEnabled() && // d527372
                          TETxLifeCycleInfo.isTraceEnabled()) // 171555.3.2
                      {
                          TETxLifeCycleInfo.traceLocalTxCommit("" + System.identityHashCode(lCoord), "Commit Local Tx - end");
                      }
                  } catch (Exception ex) {
                      FFDCFilter.processException(ex, CLASS_NAME + ".commit", "277", this);
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(tc, "Local tx completion failed", ex);
                      }
                      // By default - include cause.               d616849 d672063
                      if (ExcludeNestedExceptions) {
                          ex = null;
                      }
                      throw new CSITransactionRolledbackException("", ex);
                  }
  
              } // end else (ie. sticky local tx not required
  
          } // end if local tx exists
  
          // There was no local tx so a global tx must exist.
  
          else {
              try {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                      Tr.event(tc, "Committing TX cntxt: " + txCtrl.txService.getTransaction()); //LIDB1673.2.1.5
                  }
                  txCtrl.txService.commit(); //LIDB1673.2.1.5
  
                  // d165585 Begins
                  if (TraceComponent.isAnyTracingEnabled() && // d527372
                      TETxLifeCycleInfo.isTraceEnabled()) // PQ74774
                  {
                      TETxLifeCycleInfo.traceGlobalTxCommit("NoTx", "Commit Global Tx");
                  }
              }
              // d165585 Ends
              //445903 start: the call to commit above may throw a HeuristicMixedException.  If we simply catch
              //'Exception' (as in the second catch block below), the HeuristicMixedException is lost/eaten by our
              //Remote or Local mapping strategies.  To make sure the user sees the HeuristicMixedException, we must
              //look for (catch) it and nest it in the CSI exception.
              catch (javax.transaction.HeuristicMixedException hme) {
                  FFDCFilter.processException(hme, CLASS_NAME + ".commit", "856", this);
                  if (tc.isEventEnabled()) {
                      Tr.event(tc, "Global tx commit failed Heuristically", hme);
                  }
                  throw new CSITransactionRolledbackException("", hme);
              }
              //445903 end
              catch (Exception ex) {
                  FFDCFilter.processException(ex, CLASS_NAME + ".commit", "294", this);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                      Tr.event(tc, "Global tx commit failed", ex);
                  }
                  // By default - include cause.                  d616849 d672063
                  if (ExcludeNestedExceptions) {
                      ex = null;
                  }
                  throw new CSITransactionRolledbackException("", ex);
              }
          }
      }