[SalesForce] Exceptions and DML

It was to my understanding that when you throw an exception all previous operations are rolled back.

When an exception occurs, code execution halts and any DML
operations that were processed prior to the exception are rolled back
and aren’t committed to the database. Exceptions get logged in debug
logs.

I am running into a situation where I am able to insert a record in a logger class in the catch and throw an exception after it. What gives?

The flow is: Class A calls Class B -> Class B calls Class C -> Class C has a webservice and a try/catch

public HttpResponse postTokenizer(String securityToken, String payloadJSON) {
    try {
        if (payloadJSON == null) {
            throw new GenericException('Tokenizer was called with no IDs. The ID must be either a Contact or Lead.');
        }
        HttpRequest tokenizerRequest = new HttpRequest();
        tokenizerRequest.setMethod('POST');
        tokenizerRequest.setEndpoint(tokensAPIEndpoint);
        tokenizerRequest.setHeader('Authorization', 'token ' + securityToken);
        tokenizerRequest.setHeader('Content-Type', 'application/json');
        tokenizerRequest.setTimeout(30000);
        tokenizerRequest.setBody(payloadJSON);
        Http http = new Http();
        HttpResponse response = http.send(tokenizerRequest);
        if (!WebHelper.isSuccessStatus(response)) {
            throw new GenericException('There has been an error calling the tokenizer service.');
        }
        return response;
    } catch(Exception e) {
        NFLogger.logError('TokenizerHelper, tokenizer', 'Call to postTokenizer() failed.', e); //todo:: how is this inserting????? shouldn't this be rolled back?
        throw e;
    }
}

NFLOGGER:

global with sharing class NFLogger {
private enum LogLevel {Error, Info}

public static void logError(String tags, String errorMessage){
    logMessage(logLevel.Error, tags, errorMessage, null);
}

public static void logError(String tags, String errorMessage, System.Exception ex){
    logMessage(logLevel.Error, tags, errorMessage, ex);
}

public static void logInfo(String tags, String infoMessage){
    logMessage(logLevel.Info, tags, infoMessage, null);
}

private static void logMessage(LogLevel level, String tags, String message, System.Exception ex){
    try {
        LogMessage__c newMessage = new LogMessage__c(level__c = level.name(), tags__c = tags, message__c = message, exception__c = ex.getMessage());
        insert newMessage;
    }
    catch (Exception e){
        //intentionally we are ignoring "we suppress" any exception
        //we need to guarantee that logMessage will never throw any exceptions
    }
}
}

Best Answer

The transaction will only be rolled back automatically if the thrown exception isn't caught.

Your example showed a call stack like:

Class A calls Class B
Class B calls Class C
Class C attempts a callout to a webservice.
- It catches any resulting exceptions,
- does DML to log the exception details,
- and then throws the exception again.

Since the resulting LogMessage__c record exists after the transaction, there must be a catch in either class B or A that is handling the exception thrown by class C. This prevents the exception terminating the transaction and causing a rollback of any DML that had occured.

It looks like your quote came from Exceptions in Apex, What Happens When an Exception Occurs?. The last part of that paragraph clarifies that the transaction rollback is just for unhandled exceptions. It is probably a bit misleading to imply that a handled/caught exception would also cause a rollback.

What Happens When an Exception Occurs?

When an exception occurs, code execution halts. Any DML operations that were processed before the exception are rolled back and aren’t committed to the database. Exceptions get logged in debug logs. For unhandled exceptions, that is, exceptions that the code doesn’t catch, Salesforce sends an email that includes the exception information. The end user sees an error message in the Salesforce user interface.

Related Solutions

[SalesForce] throw an exception in apex and still log the caught exception

First please take a look at this answer for a partial solution / approach, Can I prevent an insert to be rolled back even if my class (later) runs into an exception?.

Basically as per the Apex Developers guide the final commit transaction management is baked into Apex, meaning it will always rollback if you let the platform handle your exceptions, if you don't you have to manage the rollback scope yourself or accept any DML that has been issued be committed.

If the entire request completes successfully, all changes are committed to the database. For example, suppose a Visualforce page called an Apex controller, which in turn called an additional Apex class. Only when all the Apex code has finished running and the Visualforce page has finished running, are the changes committed to the database. If the request does not complete successfully, all database changes are rolled back

The only way to get control of this is to use the try/catch/finally semantics, along with Savepoints, and critically not throwing any exception (note that as per the answer above some system exceptions cannot be caught sadly). Since your implementing the Auth.RegistrationHandler interface your stuck with its method signature and thus cannot code any alternative way to pass errors back, not does there appear to be any support for this on the interface itself.

Passing a null user back from createUser. What happens if you using try/catch/finally with a logging approach as above and then null back? I expect the system will handle this and present some general error message. Of course in this case your more detail errors will have been logged, since technically the call completed successfully. You would of course have to educate your users / admins to check your own log in this case. Given the frequency of the issues, perhaps this is tolerable? As regards the updateUser method, i don't see any way to infer errors with a successful execution of the method.

Summary and System.debug? Sorry this is not the answer you wanted, but i believe this is the situation. Your not the first to want to implement such a logging approach as you can see. Ultimately its a matter of how far your prepared to go against the transaction management semantics of the platform vs resorting to having your Admins enable Debug Logs and adding System.debug output to your code to output messages to the standard platform log that can then be reviewed for your errors.

[SalesForce] custom error logging, batch apex, failure/success counts

Yes, you can capture your logs and still have individual batches fail and rollback. For that you need to define an instance variable in your batch class - List of custom object used for logging - to store your logs while batch is running and insert them all at once in the finish() method. You will have to add Database.Stateful to your class definition (see 'Using State in Batch Apex' in this document) to ensure that your instance variable is preserved across transactions.

global class TestBatch implements Database.Batchable<sObject>, Database.Stateful {

    global List<Log__c> logs;

    global TestBatch() {
        logs = new List<Log__c>();
    }

    global Database.QueryLocator start(Database.BatchableContext BC) {
        query = 'Your query...';
        return Database.getQueryLocator(query);
    }

    global void execute(Database.BatchableContext BC, List<sObject> scope) {
        for (sobject s : scope) {
            try{
                Your logic goes here...
            } catch (Exception e) {
                logs.add(new Log__c(
                        Name__c = '...',
                        Stacktrace__c = e.getStackTraceString()
                    ));
                throw e;
            }
        }
        update scope;
    }

    global void finish(Database.BatchableContext BC) {
        insert logs;
    }
}

Best Answer

What Happens When an Exception Occurs?

Related Solutions

[SalesForce] throw an exception in apex and still log the caught exception

[SalesForce] custom error logging, batch apex, failure/success counts

Related Topic