forcedotcom/sf-skills / plugins/builder/salesforce-development/skills/platform-apex-logs-debug
platform-apex-logs-debug
VerifiedSalesforce debug log analysis and troubleshooting with 100-point scoring. TRIGGER when: user analyzes debug logs, hits governor limits, reads stack traces, or touches .log files from Salesforce orgs. DO NOT TRIGGER when: running Apex tests (use platform-apex-test-run), generating or fixing Apex code (use platform-apex-generate), or Agentforce session tracing (use agentforce-observe).
| File | Kind | Size |
|---|---|---|
| README.md | markdown | 2.2 KB |
| SKILL.md | skill md | 7.7 KB |
| assets/benchmarking-template.cls | other | 14.7 KB |
| assets/cpu-heap-optimization.cls | other | 11.8 KB |
| assets/dml-in-loop-fix.cls | other | 8.6 KB |
| assets/null-pointer-fix.cls | other | 10.4 KB |
| assets/soql-in-loop-fix.cls | other | 6.3 KB |
| references/analysis-playbook.md | markdown | 1.3 KB |
| references/benchmarking-guide.md | markdown | 7.7 KB |
| references/cli-commands.md | markdown | 8.9 KB |
| references/common-issues.md | markdown | 1.2 KB |
| references/debug-log-reference.md | markdown | 8.5 KB |
| references/log-analysis-tools.md | markdown | 7.1 KB |
| references/scoring-rubric.md | markdown | 821 B |
assets/null-pointer-fix.cls
View on GitHub/**
* NULL POINTER EXCEPTION FIX PATTERNS
*
* Problem: System.NullPointerException when accessing null object properties
* Detection: DEBUG LOG shows EXCEPTION_THROWN|NullPointerException
*
* This template demonstrates null-safe coding patterns.
*/
// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 1: SOQL QUERY RETURNING NO RESULTS
// ═══════════════════════════════════════════════════════════════════════════
public class QueryNullSafety {
// BEFORE: Dangerous - throws exception if no results
public String getAccountNameUNSAFE(Id accountId) {
Account acc = [SELECT Name FROM Account WHERE Id = :accountId];
return acc.Name; // NullPointerException if query returns nothing!
}
// AFTER: Safe - using List and isEmpty check
public String getAccountNameSAFE(Id accountId) {
List<Account> accounts = [SELECT Name FROM Account WHERE Id = :accountId LIMIT 1];
if (accounts.isEmpty()) {
return null; // Or throw custom exception, or return default
}
return accounts[0].Name;
}
// AFTER: Safe - using Safe Navigation Operator (API 62.0+)
public String getAccountNameSafeNav(Id accountId) {
Account acc = [SELECT Name FROM Account WHERE Id = :accountId LIMIT 1];
return acc?.Name; // Returns null instead of throwing exception
}
// AFTER: With default value
public String getAccountNameWithDefault(Id accountId, String defaultName) {
List<Account> accounts = [SELECT Name FROM Account WHERE Id = :accountId LIMIT 1];
return accounts.isEmpty() ? defaultName : accounts[0].Name;
}
}
// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 2: MAP ACCESS
// ═══════════════════════════════════════════════════════════════════════════
public class MapNullSafety {
// BEFORE: Dangerous - Map.get() returns null for missing keys
public void processAccountUNSAFE(Map<Id, Account> accountMap, Id targetId) {
Account acc = accountMap.get(targetId);
String name = acc.Name; // NullPointerException if targetId not in map!
}
// AFTER: Check containsKey first
public void processAccountSAFE(Map<Id, Account> accountMap, Id targetId) {
if (accountMap.containsKey(targetId)) {
Account acc = accountMap.get(targetId);
String name = acc.Name;
// Process...
}
}
// AFTER: Check for null after get
public void processAccountNullCheck(Map<Id, Account> accountMap, Id targetId) {
Account acc = accountMap.get(targetId);
if (acc != null) {
String name = acc.Name;
// Process...
}
}
// AFTER: Safe navigation (API 62.0+)
public String getAccountNameFromMap(Map<Id, Account> accountMap, Id targetId) {
return accountMap.get(targetId)?.Name;
}
}
// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 3: RELATIONSHIP FIELDS
// ═══════════════════════════════════════════════════════════════════════════
public class RelationshipNullSafety {
// BEFORE: Dangerous - parent record might be null
public String getOwnerEmailUNSAFE(Contact c) {
return c.Account.Owner.Email; // Multiple potential null points!
}
// AFTER: Check each level
public String getOwnerEmailSAFE(Contact c) {
if (c == null) return null;
if (c.Account == null) return null;
if (c.Account.Owner == null) return null;
return c.Account.Owner.Email;
}
// AFTER: Safe navigation chain (API 62.0+)
public String getOwnerEmailSafeNav(Contact c) {
return c?.Account?.Owner?.Email;
}
// AFTER: With default value
public String getOwnerEmailWithDefault(Contact c, String defaultEmail) {
String email = c?.Account?.Owner?.Email;
return String.isBlank(email) ? defaultEmail : email;
}
}
// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 4: LIST ACCESS
// ═══════════════════════════════════════════════════════════════════════════
public class ListNullSafety {
// BEFORE: Dangerous - list might be null or empty
public Contact getFirstContactUNSAFE(List<Contact> contacts) {
return contacts[0]; // IndexOutOfBoundsException if empty!
}
// AFTER: Check null and empty
public Contact getFirstContactSAFE(List<Contact> contacts) {
if (contacts == null || contacts.isEmpty()) {
return null;
}
return contacts[0];
}
// Pattern: Null-safe iteration
public void processContactsSAFE(List<Contact> contacts) {
// This is safe - for loop on null list doesn't execute
for (Contact c : contacts ?? new List<Contact>()) {
// Process contact
}
}
// Alternative: Early return
public void processContactsEarlyReturn(List<Contact> contacts) {
if (contacts == null || contacts.isEmpty()) {
return;
}
for (Contact c : contacts) {
// Process contact
}
}
}
// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 5: STRING OPERATIONS
// ═══════════════════════════════════════════════════════════════════════════
public class StringNullSafety {
// BEFORE: Dangerous - string might be null
public Boolean containsKeywordUNSAFE(String text, String keyword) {
return text.contains(keyword); // NullPointerException if text is null!
}
// AFTER: Use String.isNotBlank() or String.isBlank()
public Boolean containsKeywordSAFE(String text, String keyword) {
if (String.isBlank(text) || String.isBlank(keyword)) {
return false;
}
return text.contains(keyword);
}
// Pattern: Null-safe string comparison
public Boolean isEqualSAFE(String a, String b) {
// Both null = equal
if (a == null && b == null) return true;
// One null = not equal
if (a == null || b == null) return false;
// Both non-null = compare
return a.equals(b);
}
// Pattern: Default value for null strings
public String getNameWithDefault(Account acc) {
return String.isBlank(acc?.Name) ? 'Unnamed Account' : acc.Name;
}
}
// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 6: TRIGGER CONTEXT
// ═══════════════════════════════════════════════════════════════════════════
public class TriggerNullSafety {
/**
* In triggers, old values might not exist (insert)
* and new values might not exist (delete)
*/
public void handleTrigger() {
// Safe: Check context first
if (Trigger.isInsert) {
// Trigger.old is null in insert context
for (Account acc : (List<Account>)Trigger.new) {
// Process new records
}
}
if (Trigger.isUpdate) {
Map<Id, Account> oldMap = (Map<Id, Account>)Trigger.oldMap;
for (Account newAcc : (List<Account>)Trigger.new) {
Account oldAcc = oldMap.get(newAcc.Id);
// Both old and new are available
if (oldAcc.Status__c != newAcc.Status__c) {
// Status changed
}
}
}
if (Trigger.isDelete) {
// Trigger.new is null in delete context
for (Account acc : (List<Account>)Trigger.old) {
// Process deleted records
}
}
}
}
// ═══════════════════════════════════════════════════════════════════════════
// ANTI-PATTERN: OVER-DEFENSIVE CODING
// ═══════════════════════════════════════════════════════════════════════════
public class OverDefensiveCoding {
/**
* Don't check for null when it's impossible
* This adds unnecessary code and cognitive load
*/
// UNNECESSARY: Trigger.new is never null in insert/update context
public void badExample() {
if (Trigger.new != null && !Trigger.new.isEmpty()) {
for (SObject record : Trigger.new) {
// Trigger.new is guaranteed non-null in before/after insert/update
}
}
}
// CORRECT: Trust the platform guarantees
public void goodExample() {
for (Account acc : (List<Account>)Trigger.new) {
// Just use it - Trigger.new is guaranteed in this context
}
}
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |