@salesforce/afv-skills 1.8.0 → 1.9.0

package/skills/debugging-apex-logs/assets/benchmarking-template.cls

@@ -0,0 +1,327 @@
+/**
+ * Apex Benchmarking Template
+ *
+ * Reliable performance testing using established Apex benchmarking techniques.
+ * Run in Anonymous Apex for consistent results.
+ *
+ * Features:
+ * - Warm-up phase to normalize JIT compilation
+ * - Multiple iterations for statistical accuracy
+ * - Side-by-side comparison of two approaches
+ * - Automatic winner determination
+ *
+ * See: references/benchmarking-guide.md for methodology and benchmark data
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SIMPLE BENCHMARK (Copy into Anonymous Apex)
+// ═══════════════════════════════════════════════════════════════════════════
+
+// Quick single-operation benchmark
+Long startTime = System.currentTimeMillis();
+
+for (Integer i = 0; i < 10000; i++) {
+    // Your operation here
+    String s = 'test'.toUpperCase();
+}
+
+Long duration = System.currentTimeMillis() - startTime;
+System.debug('Duration: ' + duration + 'ms');
+System.debug('Per iteration: ' + (duration / 10000.0) + 'ms');
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// COMPARISON BENCHMARK CLASS
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Compare two implementations side-by-side
+ *
+ * Usage in Anonymous Apex:
+ *   BenchmarkComparison.run();
+ */
+public class BenchmarkComparison {
+
+    private static final Integer ITERATIONS = 10000;
+    private static final Integer WARMUP_ITERATIONS = 100;
+
+    public static void run() {
+        System.debug('═══════════════════════════════════════════════════════');
+        System.debug('BENCHMARK: [Description Here]');
+        System.debug('Iterations: ' + ITERATIONS);
+        System.debug('═══════════════════════════════════════════════════════');
+
+        // Warm-up phase (normalizes JIT compilation effects)
+        System.debug('\n🔥 Warm-up phase...');
+        for (Integer i = 0; i < WARMUP_ITERATIONS; i++) {
+            methodA();
+            methodB();
+        }
+        System.debug('   Warm-up complete');
+
+        // Benchmark Method A
+        System.debug('\n📊 Running Method A...');
+        Long startA = System.currentTimeMillis();
+        for (Integer i = 0; i < ITERATIONS; i++) {
+            methodA();
+        }
+        Long durationA = System.currentTimeMillis() - startA;
+
+        // Benchmark Method B
+        System.debug('📊 Running Method B...');
+        Long startB = System.currentTimeMillis();
+        for (Integer i = 0; i < ITERATIONS; i++) {
+            methodB();
+        }
+        Long durationB = System.currentTimeMillis() - startB;
+
+        // Results
+        System.debug('\n═══════════════════════════════════════════════════════');
+        System.debug('RESULTS');
+        System.debug('═══════════════════════════════════════════════════════');
+        System.debug('Method A: ' + durationA + 'ms (' + (durationA / (Decimal)ITERATIONS) + 'ms per iteration)');
+        System.debug('Method B: ' + durationB + 'ms (' + (durationB / (Decimal)ITERATIONS) + 'ms per iteration)');
+        System.debug('───────────────────────────────────────────────────────');
+
+        Long difference = Math.abs(durationA - durationB);
+        String winner = durationA < durationB ? 'Method A' : 'Method B';
+        Decimal improvement = durationA < durationB
+            ? (durationB / (Decimal)durationA)
+            : (durationA / (Decimal)durationB);
+
+        System.debug('🏆 Winner: ' + winner);
+        System.debug('   Difference: ' + difference + 'ms');
+        System.debug('   Improvement: ' + improvement.setScale(1) + 'x faster');
+
+        // Governor limits status
+        System.debug('\n📈 Governor Limits Used:');
+        System.debug('   CPU Time: ' + Limits.getCpuTime() + '/' + Limits.getLimitCpuTime() + 'ms');
+        System.debug('   Heap Size: ' + Limits.getHeapSize() + '/' + Limits.getLimitHeapSize() + ' bytes');
+    }
+
+    // ═══════════════════════════════════════════════════════════════════
+    // METHODS TO COMPARE (Replace with your implementations)
+    // ═══════════════════════════════════════════════════════════════════
+
+    private static void methodA() {
+        // Implementation A - e.g., String concatenation
+        String result = '';
+        for (Integer i = 0; i < 10; i++) {
+            result += 'item' + i + ',';
+        }
+    }
+
+    private static void methodB() {
+        // Implementation B - e.g., String.join()
+        List<String> items = new List<String>();
+        for (Integer i = 0; i < 10; i++) {
+            items.add('item' + i);
+        }
+        String result = String.join(items, ',');
+    }
+}
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// DATA STRUCTURE BENCHMARK
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Compare List vs Set vs Map lookup performance
+ *
+ * Expected Results:
+ *   List.contains(): O(n) - slow
+ *   Set.contains(): O(1) - fast
+ *   Map.containsKey(): O(1) - fast
+ */
+public class DataStructureBenchmark {
+
+    private static final Integer DATA_SIZE = 1000;
+    private static final Integer LOOKUPS = 5000;
+
+    public static void run() {
+        // Setup test data
+        List<String> testList = new List<String>();
+        Set<String> testSet = new Set<String>();
+        Map<String, Boolean> testMap = new Map<String, Boolean>();
+
+        for (Integer i = 0; i < DATA_SIZE; i++) {
+            String key = 'key_' + i;
+            testList.add(key);
+            testSet.add(key);
+            testMap.put(key, true);
+        }
+
+        // Random lookup keys (mix of existing and non-existing)
+        List<String> lookupKeys = new List<String>();
+        for (Integer i = 0; i < LOOKUPS; i++) {
+            lookupKeys.add('key_' + Math.mod(i * 7, DATA_SIZE * 2));
+        }
+
+        System.debug('═══════════════════════════════════════════════════════');
+        System.debug('DATA STRUCTURE LOOKUP BENCHMARK');
+        System.debug('Data Size: ' + DATA_SIZE + ' | Lookups: ' + LOOKUPS);
+        System.debug('═══════════════════════════════════════════════════════');
+
+        // List.contains()
+        Long startList = System.currentTimeMillis();
+        for (String key : lookupKeys) {
+            Boolean found = testList.contains(key);
+        }
+        Long durationList = System.currentTimeMillis() - startList;
+
+        // Set.contains()
+        Long startSet = System.currentTimeMillis();
+        for (String key : lookupKeys) {
+            Boolean found = testSet.contains(key);
+        }
+        Long durationSet = System.currentTimeMillis() - startSet;
+
+        // Map.containsKey()
+        Long startMap = System.currentTimeMillis();
+        for (String key : lookupKeys) {
+            Boolean found = testMap.containsKey(key);
+        }
+        Long durationMap = System.currentTimeMillis() - startMap;
+
+        // Results
+        System.debug('\nRESULTS:');
+        System.debug('List.contains(): ' + durationList + 'ms');
+        System.debug('Set.contains():  ' + durationSet + 'ms');
+        System.debug('Map.containsKey(): ' + durationMap + 'ms');
+
+        if (durationList > 0) {
+            System.debug('\nSet is ' + (durationList / Math.max(1, durationSet)) + 'x faster than List');
+        }
+    }
+}
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// LOOP STYLE BENCHMARK
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Compare different loop constructs
+ *
+ * Expected Results (from documented Apex loop benchmarks):
+ *   While loop: ~0.4s (fastest)
+ *   Cached iterator: ~0.8s
+ *   For loop (index): ~1.4s
+ *   Enhanced for-each: ~2.4s
+ */
+public class LoopBenchmark {
+
+    private static final Integer ITERATIONS = 10000;
+
+    public static void run() {
+        // Create test data
+        List<Integer> numbers = new List<Integer>();
+        for (Integer i = 0; i < 1000; i++) {
+            numbers.add(i);
+        }
+
+        System.debug('═══════════════════════════════════════════════════════');
+        System.debug('LOOP STYLE BENCHMARK');
+        System.debug('Outer Iterations: ' + ITERATIONS + ' | List Size: ' + numbers.size());
+        System.debug('═══════════════════════════════════════════════════════');
+
+        // While loop with iterator
+        Long startWhile = System.currentTimeMillis();
+        for (Integer outer = 0; outer < ITERATIONS; outer++) {
+            Iterator<Integer> iter = numbers.iterator();
+            while (iter.hasNext()) {
+                Integer num = iter.next();
+            }
+        }
+        Long durationWhile = System.currentTimeMillis() - startWhile;
+
+        // Traditional for loop
+        Long startFor = System.currentTimeMillis();
+        for (Integer outer = 0; outer < ITERATIONS; outer++) {
+            for (Integer i = 0; i < numbers.size(); i++) {
+                Integer num = numbers[i];
+            }
+        }
+        Long durationFor = System.currentTimeMillis() - startFor;
+
+        // Enhanced for-each
+        Long startEnhanced = System.currentTimeMillis();
+        for (Integer outer = 0; outer < ITERATIONS; outer++) {
+            for (Integer num : numbers) {
+                // Just iterate
+            }
+        }
+        Long durationEnhanced = System.currentTimeMillis() - startEnhanced;
+
+        // Results
+        System.debug('\nRESULTS:');
+        System.debug('While loop:     ' + durationWhile + 'ms');
+        System.debug('For loop:       ' + durationFor + 'ms');
+        System.debug('Enhanced for:   ' + durationEnhanced + 'ms');
+
+        System.debug('\n📊 Analysis:');
+        Long fastest = Math.min(durationWhile, Math.min(durationFor, durationEnhanced));
+        if (durationWhile == fastest) {
+            System.debug('🏆 While loop is fastest');
+        } else if (durationFor == fastest) {
+            System.debug('🏆 For loop is fastest');
+        } else {
+            System.debug('🏆 Enhanced for is fastest');
+        }
+    }
+}
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// STRING BENCHMARK (demonstrates 22x improvement)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * String concatenation vs String.join()
+ *
+ * Expected Results (from documented Apex benchmarks):
+ *   Concatenation: 11,767ms for 1,750 items (CPU LIMIT)
+ *   String.join(): 539ms for 7,500 items (still running)
+ *   Improvement: ~22x faster
+ */
+public class StringBenchmark {
+
+    public static void run() {
+        System.debug('═══════════════════════════════════════════════════════');
+        System.debug('STRING BUILDING BENCHMARK');
+        System.debug('═══════════════════════════════════════════════════════');
+
+        // Test with safe number of items
+        Integer itemCount = 500;
+
+        // Method 1: String concatenation (BAD)
+        Long startConcat = System.currentTimeMillis();
+        String resultConcat = '';
+        for (Integer i = 0; i < itemCount; i++) {
+            resultConcat += 'Item_' + i + '_Name\n';
+        }
+        Long durationConcat = System.currentTimeMillis() - startConcat;
+
+        // Method 2: String.join() (GOOD)
+        Long startJoin = System.currentTimeMillis();
+        List<String> items = new List<String>();
+        for (Integer i = 0; i < itemCount; i++) {
+            items.add('Item_' + i + '_Name');
+        }
+        String resultJoin = String.join(items, '\n');
+        Long durationJoin = System.currentTimeMillis() - startJoin;
+
+        // Results
+        System.debug('\nRESULTS (' + itemCount + ' items):');
+        System.debug('String +=:      ' + durationConcat + 'ms');
+        System.debug('String.join():  ' + durationJoin + 'ms');
+
+        if (durationJoin > 0 && durationConcat > durationJoin) {
+            System.debug('\n🏆 String.join() is ' + (durationConcat / durationJoin) + 'x faster!');
+        }
+
+        System.debug('\n⚠️ WARNING: With larger datasets, concatenation hits CPU limit!');
+        System.debug('   Documented benchmark: 11,767ms for 1,750 items (concat) vs 539ms for 7,500 items (join)');
+    }
+}

package/skills/debugging-apex-logs/assets/cpu-heap-optimization.cls

@@ -0,0 +1,307 @@
+/**
+ * CPU TIME AND HEAP SIZE OPTIMIZATION PATTERNS
+ *
+ * CPU Limits:
+ *   - Synchronous: 10,000 ms
+ *   - Asynchronous: 60,000 ms
+ *
+ * Heap Limits:
+ *   - Synchronous: 6 MB
+ *   - Asynchronous: 12 MB
+ *
+ * This template demonstrates optimization patterns for CPU and heap limits.
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CPU OPTIMIZATION: ALGORITHM COMPLEXITY
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class CPUOptimization {
+
+    // BEFORE: O(n²) - Nested loops are expensive
+    public void findDuplicatesBAD(List<Contact> contacts) {
+        List<Contact> duplicates = new List<Contact>();
+
+        for (Integer i = 0; i < contacts.size(); i++) {
+            for (Integer j = i + 1; j < contacts.size(); j++) {
+                if (contacts[i].Email == contacts[j].Email) {
+                    duplicates.add(contacts[j]);
+                }
+            }
+        }
+    }
+
+    // AFTER: O(n) - Use Map for lookups
+    public List<Contact> findDuplicatesGOOD(List<Contact> contacts) {
+        Map<String, Contact> emailToContact = new Map<String, Contact>();
+        List<Contact> duplicates = new List<Contact>();
+
+        for (Contact c : contacts) {
+            if (c.Email == null) continue;
+
+            String normalizedEmail = c.Email.toLowerCase();
+            if (emailToContact.containsKey(normalizedEmail)) {
+                duplicates.add(c);
+            } else {
+                emailToContact.put(normalizedEmail, c);
+            }
+        }
+
+        return duplicates;
+    }
+
+    // BEFORE: Expensive string concatenation in loop
+    public String buildReportBAD(List<Account> accounts) {
+        String report = '';
+        for (Account acc : accounts) {
+            report += acc.Name + '\n';  // Creates new string each iteration!
+        }
+        return report;
+    }
+
+    // AFTER: Use List and join
+    public String buildReportGOOD(List<Account> accounts) {
+        List<String> lines = new List<String>();
+        for (Account acc : accounts) {
+            lines.add(acc.Name);
+        }
+        return String.join(lines, '\n');
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CPU OPTIMIZATION: CACHING
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class CachingPatterns {
+
+    // Cache expensive calculations
+    private static Map<String, Decimal> calculationCache = new Map<String, Decimal>();
+
+    public static Decimal getDiscountRate(String productCode, String region) {
+        String cacheKey = productCode + ':' + region;
+
+        if (calculationCache.containsKey(cacheKey)) {
+            return calculationCache.get(cacheKey);  // Cache hit - no CPU cost
+        }
+
+        // Expensive calculation only happens once per unique key
+        Decimal rate = performExpensiveCalculation(productCode, region);
+        calculationCache.put(cacheKey, rate);
+
+        return rate;
+    }
+
+    private static Decimal performExpensiveCalculation(String productCode, String region) {
+        // Simulate complex calculation
+        return 0.15;
+    }
+
+    // Platform Cache for cross-transaction caching
+    public static Decimal getDiscountRateWithPlatformCache(String productCode, String region) {
+        String cacheKey = 'discount_' + productCode + '_' + region;
+
+        // Try to get from Platform Cache (Org partition)
+        Cache.OrgPartition orgPart = Cache.Org.getPartition('local.DiscountCache');
+        Decimal cachedRate = (Decimal)orgPart.get(cacheKey);
+
+        if (cachedRate != null) {
+            return cachedRate;
+        }
+
+        // Calculate and cache
+        Decimal rate = performExpensiveCalculation(productCode, region);
+        orgPart.put(cacheKey, rate, 3600);  // Cache for 1 hour
+
+        return rate;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// HEAP OPTIMIZATION: LARGE DATA PROCESSING
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class HeapOptimization {
+
+    // BEFORE: Loads all records into heap at once
+    public void processAllAccountsBAD() {
+        List<Account> allAccounts = [SELECT Id, Name FROM Account];  // Could be millions!
+
+        for (Account acc : allAccounts) {
+            // Process each account
+        }
+    }
+
+    // AFTER: SOQL FOR loop - streams records, doesn't load all into heap
+    public void processAllAccountsGOOD() {
+        for (Account acc : [SELECT Id, Name FROM Account]) {
+            // Each record is loaded individually
+            // Previous record can be garbage collected
+            processAccount(acc);
+        }
+    }
+
+    private void processAccount(Account acc) {
+        // Process single account
+    }
+
+    // AFTER: Batch processing for very large datasets
+    public void processAllAccountsBATCH() {
+        // Use Database.executeBatch for millions of records
+        Database.executeBatch(new AccountProcessorBatch(), 200);
+    }
+}
+
+// Batch class for large datasets
+public class AccountProcessorBatch implements Database.Batchable<SObject> {
+
+    public Database.QueryLocator start(Database.BatchableContext bc) {
+        return Database.getQueryLocator('SELECT Id, Name FROM Account');
+    }
+
+    public void execute(Database.BatchableContext bc, List<Account> scope) {
+        // Process 200 records at a time (controlled heap usage)
+        for (Account acc : scope) {
+            // Process each account
+        }
+    }
+
+    public void finish(Database.BatchableContext bc) {
+        // Optional: Send completion notification
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// HEAP OPTIMIZATION: CLEARING REFERENCES
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class HeapClearingPatterns {
+
+    // Clear large collections when no longer needed
+    public void processWithClearing() {
+        // Phase 1: Query and process
+        List<Account> accounts = [SELECT Id, Name FROM Account LIMIT 10000];
+        Map<Id, String> accountNames = new Map<Id, String>();
+
+        for (Account acc : accounts) {
+            accountNames.put(acc.Id, acc.Name);
+        }
+
+        // Clear the original list - no longer needed
+        accounts.clear();
+        accounts = null;
+
+        // Phase 2: Use the map
+        for (Id accId : accountNames.keySet()) {
+            // Process using map
+        }
+
+        // Clear the map when done
+        accountNames.clear();
+        accountNames = null;
+    }
+
+    // Use transient for Visualforce controllers
+    public class LargeDataController {
+        // transient = not stored in view state, reduces heap in page transitions
+        transient public List<Account> largeAccountList { get; set; }
+
+        public LargeDataController() {
+            largeAccountList = [SELECT Id, Name FROM Account LIMIT 5000];
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CPU OPTIMIZATION: ASYNC PROCESSING
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class AsyncProcessingPatterns {
+
+    // Move expensive operations to @future
+    @future
+    public static void processExpensiveOperation(Set<Id> recordIds) {
+        // Has 60 second CPU limit instead of 10 seconds
+        for (Id recordId : recordIds) {
+            // Expensive processing
+        }
+    }
+
+    // Use Queueable for chained processing
+    public class ExpensiveQueueable implements Queueable {
+        private List<Id> recordIds;
+
+        public ExpensiveQueueable(List<Id> recordIds) {
+            this.recordIds = recordIds;
+        }
+
+        public void execute(QueueableContext context) {
+            // Process first batch
+            List<Id> batch = new List<Id>();
+            List<Id> remaining = new List<Id>();
+
+            for (Integer i = 0; i < recordIds.size(); i++) {
+                if (i < 100) {
+                    batch.add(recordIds[i]);
+                } else {
+                    remaining.add(recordIds[i]);
+                }
+            }
+
+            // Process this batch
+            processBatch(batch);
+
+            // Chain next batch if needed
+            if (!remaining.isEmpty()) {
+                System.enqueueJob(new ExpensiveQueueable(remaining));
+            }
+        }
+
+        private void processBatch(List<Id> batch) {
+            // Process 100 records
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PATTERN: LIMITS MONITORING
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class LimitsMonitoring {
+
+    // Check limits during execution
+    public void processWithLimitChecking(List<Account> accounts) {
+        Integer cpuWarning = 8000;  // 80% of 10,000ms limit
+        Integer heapWarning = 4800000;  // 80% of 6MB limit
+
+        for (Account acc : accounts) {
+            // Check CPU limit
+            if (Limits.getCpuTime() > cpuWarning) {
+                System.debug(LoggingLevel.WARN,
+                    'CPU limit approaching: ' + Limits.getCpuTime() + 'ms');
+                // Consider switching to async
+                break;
+            }
+
+            // Check heap limit
+            if (Limits.getHeapSize() > heapWarning) {
+                System.debug(LoggingLevel.WARN,
+                    'Heap limit approaching: ' + Limits.getHeapSize() + ' bytes');
+                break;
+            }
+
+            processAccount(acc);
+        }
+    }
+
+    // Debug helper: Print all limits
+    public static void debugLimits() {
+        System.debug('=== GOVERNOR LIMITS ===');
+        System.debug('SOQL Queries: ' + Limits.getQueries() + '/' + Limits.getLimitQueries());
+        System.debug('DML Statements: ' + Limits.getDmlStatements() + '/' + Limits.getLimitDmlStatements());
+        System.debug('DML Rows: ' + Limits.getDmlRows() + '/' + Limits.getLimitDmlRows());
+        System.debug('CPU Time: ' + Limits.getCpuTime() + '/' + Limits.getLimitCpuTime());
+        System.debug('Heap Size: ' + Limits.getHeapSize() + '/' + Limits.getLimitHeapSize());
+        System.debug('Callouts: ' + Limits.getCallouts() + '/' + Limits.getLimitCallouts());
+    }
+}