Context & Related Objects
Maximizing the value of your log data through rich context and related object tracking in Triton logging.
Maximizing Log Value
The most valuable logs contain rich context that enables effective debugging and analysis. Triton provides powerful capabilities for capturing comprehensive context and tracking related objects.
Related Objects
Apex β Single Object
Triton.instance.log(
Triton.instance.fromTemplate()
.relatedObject(accountId) // Single related object
.summary('Account processed')
.details('status=completed')
);Apex β Multiple Objects
// Order processing with related objects
public class OrderProcessingService {
public static void processOrder(Id orderId) {
// Set up template for order processing
Triton.instance.setTemplate(
Triton.makeBuilder()
.category(TritonTypes.Category.Apex)
.type(TritonTypes.Type.Backend)
.area(TritonTypes.Area.OrderProcessing)
.relatedObject(orderId) // Primary object
);
try {
// Get related records
Order order = [SELECT Id, AccountId, OpportunityId FROM Order WHERE Id = :orderId];
// Process order
processOrderLogic(order);
// Log success with all related objects
Triton.instance.log(
Triton.instance.fromTemplate()
.summary('Order processed successfully')
.details('orderId=' + orderId)
.relatedObjects(new Set<Id>{
orderId, // Order
order.AccountId, // Account
order.OpportunityId // Opportunity
})
);
} catch (Exception e) {
Triton.instance.log(
Triton.instance.fromTemplate()
.exception(e)
.summary('Order processing failed')
);
throw e;
}
}
}LWC β Related Objects
// LWC component with related object tracking
export default class OrderManager extends LightningElement {
triton;
connectedCallback() {
this.triton = new Triton().bindToComponent('c-order-manager');
// Set up template with primary related object
this.triton.setTemplate(
this.triton.makeBuilder()
.type(TYPE.FRONTEND)
.area(AREA.ORDER_MANAGEMENT)
.relatedObjects([this.recordId]) // Primary order
);
}
async handleOrderUpdate() {
try {
const result = await updateOrder({
orderId: this.recordId,
orderData: this.orderData
});
// Log with all related objects
this.triton.log(
this.triton.fromTemplate()
.summary('Order updated successfully')
.details(JSON.stringify({
orderId: this.recordId,
accountId: result.AccountId,
opportunityId: result.OpportunityId
}))
.relatedObjects([
this.recordId, // Order
result.AccountId, // Account
result.OpportunityId // Opportunity
])
);
} catch (error) {
this.triton.logNow(
this.triton.fromTemplate()
.exception(error)
.summary('Order update failed')
);
}
}
}Rich Context Capture
Duration Tracking
public class PerformanceTracking {
public static void processBatch(List<SObject> records) {
Long startTime = System.now().getTime();
Triton.instance.setTemplate(
Triton.makeBuilder()
.category(TritonTypes.Category.Apex)
.type(TritonTypes.Type.Backend)
.area(TritonTypes.Area.BatchProcessing)
);
try {
// Process records
for (SObject record : records) {
processRecord(record);
}
// Log completion with duration
Triton.instance.log(
Triton.instance.fromTemplate()
.summary('Batch processing completed')
.details('processed=' + records.size())
.duration(System.now().getTime() - startTime)
.relatedObjects(new Map<Id, SObject>(records).keySet())
);
} catch (Exception e) {
Triton.instance.log(
Triton.instance.fromTemplate()
.exception(e)
.summary('Batch processing failed')
.duration(System.now().getTime() - startTime)
);
throw e;
}
}
}Integration Payloads
public class IntegrationService {
public static void callExternalAPI(String endpoint, String payload) {
Long startTime = System.now().getTime();
Triton.instance.setTemplate(
Triton.makeBuilder()
.category(TritonTypes.Category.Integration)
.type(TritonTypes.Type.Backend)
.area(TritonTypes.Area.ExternalAPI)
);
HttpRequest req = new HttpRequest();
req.setEndpoint(endpoint);
req.setMethod('POST');
req.setBody(payload);
try {
HttpResponse response = new Http().send(req);
if (response.getStatusCode() == 200) {
// Log successful call with payload
Triton.instance.log(
Triton.instance.fromTemplate()
.summary('External API call successful')
.details('endpoint=' + endpoint + ', statusCode=' + response.getStatusCode())
.integrationPayload(req, response)
.duration(System.now().getTime() - startTime)
);
} else {
// Log failed call with payload
Triton.instance.log(
Triton.instance.fromTemplate()
.summary('External API call failed')
.details('endpoint=' + endpoint + ', statusCode=' + response.getStatusCode())
.integrationPayload(req, response)
.duration(System.now().getTime() - startTime)
);
}
} catch (Exception e) {
// Log exception with request payload
Triton.instance.log(
Triton.instance.fromTemplate()
.exception(e)
.summary('External API call failed')
.details('endpoint=' + endpoint)
.integrationPayload(req, null)
.duration(System.now().getTime() - startTime)
);
throw e;
}
}
}Context Enrichment
User Context
public class UserContextLogger {
public static void logUserAction(String action, Id recordId) {
Triton.instance.log(
Triton.makeBuilder()
.category(TritonTypes.Category.Apex)
.type(TritonTypes.Type.Backend)
.area(TritonTypes.Area.UserActions)
.relatedObject(recordId)
.userId(UserInfo.getUserId()) // Current user
.summary('User action: ' + action)
.details('user=' + UserInfo.getName() + ', profile=' + UserInfo.getProfileId())
);
}
}Runtime Information
// LWC with runtime information
export default class PerformanceComponent extends LightningElement {
triton;
connectedCallback() {
this.triton = new Triton().bindToComponent('c-performance-component');
// Log component initialization with runtime info
this.triton.log(
this.triton.makeBuilder()
.type(TYPE.FRONTEND)
.area(AREA.PERFORMANCE)
.summary('Component initialized')
.details(JSON.stringify({
userAgent: navigator.userAgent,
screenSize: `${screen.width}x${screen.height}`,
timestamp: new Date().toISOString()
}))
);
}
}Best Practices
Related Object Strategy
Primary object: Always include the main object being processed
Related records: Include parent/child relationships that are relevant to the operation
Transaction scope: Include all objects that are part of the same transaction
Error context: Ensure related objects are included even in error scenarios
Context Enrichment
Duration tracking: Measure and log processing time for performance analysis
Integration payloads: Always include request/response data for external calls
User context: Include user information for audit trails
Runtime information: Capture relevant system/environment details
Performance Considerations
Object limits: Be mindful of the number of related objects (avoid excessive lists)
Payload size: Sanitize integration payloads to avoid storage issues
Memory usage: Consider the impact of rich context on memory consumption
Filtering: Use context to enable effective log filtering and analysis
Advanced Patterns
Dynamic Related Objects
public class DynamicObjectTracker {
public static void processWithDynamicObjects(Id primaryId, Set<Id> relatedIds) {
Set<Id> allObjects = new Set<Id>{ primaryId };
allObjects.addAll(relatedIds);
Triton.instance.log(
Triton.instance.fromTemplate()
.summary('Dynamic object processing')
.details('primary=' + primaryId + ', related=' + relatedIds.size())
.relatedObjects(allObjects)
);
}
}Context Templates
public class ContextTemplate {
public static void setRichTemplate(Id recordId, String operation) {
Triton.instance.setTemplate(
Triton.makeBuilder()
.category(TritonTypes.Category.Apex)
.type(TritonTypes.Type.Backend)
.area(TritonTypes.Area.DataProcessing)
.relatedObject(recordId)
.summary(operation)
.details('timestamp=' + System.now() + ', user=' + UserInfo.getName())
);
}
}By maximizing context and related object tracking, you'll create logs that provide comprehensive debugging information and enable powerful analysis capabilities across your Salesforce org.
Last updated