Need help-apex cpu time limit exceeded

Question

I scheduled an apex job to run daily at midnight but noticed that the job failed due to the Apex CPU time limit exceeded error. The code works in my developer sandbox but not in production. I'm wondering if it is because of something in my SOQL query, but unclear on where the culprit would be. The query only returns about 500 records in production. Any help is appreciated- here is my class:

global without sharing class UnassignAccountsDueToInactivity implements Schedulable {
  global void execute(SchedulableContext ctx) {
    List<Account> acctList = [SELECT Id, Name, OwnerId 
                              FROM Account 
                              WHERE (OwnerProfileName__c LIKE '%AE%' OR OwnerProfileName__c LIKE '%SDR%') AND 
                              (Current_Customer__c != 'Current Customer A' AND Current_Customer__c != 'Current Customer B' AND Current_Customer__c != 'Current Customer C') AND
                              Number_of_Open_Opportunities__c <= 0 AND
                              DaysSinceLastActivity__c >= 30 AND
                              DaysSinceLastOwnerChangeDate__c >= 7];

    if(!acctList.isEmpty()){
      for(Account acc : acctList){
        acc.DisqualifiedReason__c = 'No response';
        acc.OwnerId = '000000000000000';
      }
      update acctList;
    }
  }
}

Answer 1

I recommend you use Data Loader for this task.

1. Export the query you have already written
2. Manipulate the CSV to set DisqualifiedReason__c and OwnerId to the proper values.
3. Import the manipulated CSV

You don't need any Apex if you approach the task this way. You can also break the query out into a few discrete chunks to simplify the SOQL.

If you still want this logic to run daily and expect large volumes, you should use a batch to chunk the records.

public with sharing class MyBatch implements Database.Batchable<SObject>, Schedulable
{
    public void execute(SchedulableContext context) { Database.executeBatch(this); }
    public Database.QueryLocator start(Datbase.BatchableContext context)
    {
        return Database.getQueryLocator([/*current query*/]);
    }
    public void execute(Database.BatchableContext context, List<Account> records)
    {
        for(Account record: records){
            record.DisqualifiedReason__c = 'No response';
            record.OwnerId = '000000000000000';
        }
        update records;
    }
    public void finish(Database.BatchableContext context)
    {
        // optional implementation
    }
}

If you are still having trouble with timeouts, you can reduce the batch size in your execute(SchedulableContext) method. You could go as low as one record per chunk, though this size would cause your batch to run quite slowly.

Database.executeBatch(this, 1); // default is 200

Answer 2

I'd go with running restructuring your code into a batchable where you start the batchable from the execute method of the schedulable. (This is Adrian's second suggestion clarified a bit.) This way you can kick off the batchable at an appropriate time, and break the work down into chunks that stay within the governor limits.

Answer 3

Note that when you do the update statement (of 500 Accounts), the transaction scope is all 500 records even though any trigger/PB/WF on Account will be chunked in groups of 200,200 and 100 Accounts. It is these downstream functions that are most likely burning through your CPU.

Depending on your business, you could consider dynamically disabling the triggers and process builders/WFs with some gate (switch) as a straight up DML of 500 Accounts should comfortably run in the available CPU time. Such a gate might be based on a known running user (a dedicated user that schedules the job).

All that said, to future proof all of this, I agree 100% with Adrian's batchable suggestion.