Observability and Monitoring Strategies for Salesforce Development

Written By Gary Elbaum

Salesforce development presents unique challenges for observability and monitoring, especially given the mix of Apex code, declarative automation (Flows), and numerous integrations with external systems. While the Salesforce platform doesn't natively offer an all-encompassing observability suite like what you find in typical web application stacks, there are multiple strategies and tools you can leverage to gain visibility into performance, exceptions, and system behavior.

Native Salesforce Monitoring Capabilities

Salesforce provides several built-in tools that form the foundation of observability:

  • Debug Logs: Useful for granular tracing of Apex execution, SOQL queries, and workflow operations. However, they can be cumbersome to use for large scale or real-time monitoring.

  • Apex Exception Emails: Automatic notifications when unhandled Apex exceptions occur.

  • Flow Error Emails and Debug Logs: For tracking failures and debugging Flows.

  • Event Monitoring (part of Salesforce Shield): Offers detailed logs on user activity, API calls, performance metrics, and more. It’s highly useful but requires additional licensing.

  • Apex Jobs and Scheduled Jobs Monitoring: Native UI to track asynchronous job status like batch Apex, queueable Apex, and scheduled jobs.

  • API Usage and Limits: Salesforce Setup UI provides insights into API calls and consumption limits.

While these tools cover basic monitoring needs, they fall short on centralized log aggregation, real-time alerting at scale, and deep performance analytics.

Third-Party Tools and Integrations

To address the gaps, many Salesforce teams integrate with third-party observability platforms:

  • Splunk: Commonly used for ingesting Salesforce event logs (via Event Monitoring API) and Apex logs. Enables powerful search, dashboards, and alerting.

  • Datadog: Can be integrated with Salesforce via APIs or custom log forwarders, consolidating logs and metrics alongside other parts of your system.

  • New Relic and AppDynamics: Primarily focused on external app monitoring, but can pull Salesforce integration metrics and API latency data as part of overall application performance management.

  • Sentry: While it does not directly support Salesforce, it can be used with custom Apex logging frameworks that send errors and exceptions via REST API to Sentry for centralized alerting.

Custom-Built Monitoring Solutions

Given the platform constraints, many organizations build custom solutions to enhance observability:

  • Custom Logging Frameworks in Apex: Wrapping critical logic with try-catch blocks that write detailed error and performance data to custom objects. This allows querying and reporting directly in Salesforce.

  • Flow Failure Handling: Utilizing fault paths in Flows to log errors to custom objects or external systems.

  • Scheduled Batch Jobs for Data Aggregation: Periodically summarizing logs or job statuses for easier performance and health monitoring.

  • Outbound Messaging or Platform Events: Emitting notifications or diagnostics data to external systems for aggregation.

Tracking Technical Debt and Performance Bottlenecks

Monitoring technical debt and slow-running transactions in Salesforce requires a combination of:

  • Code Quality Tools: Using static code analyzers and Salesforce-specific linters to detect code smells and inefficiencies.

  • Apex CPU Time Tracking: Monitoring governor limits and CPU time consumption per transaction via debug logs or event monitoring.

  • Performance Insights Dashboard: Aggregating long-running SOQL queries, DML operations, and asynchronous job durations.

  • Change Management and Documentation: Keeping detailed records of known issues, deprecated components, and Salesforce releases/deprecations impacting performance.

Integrating Salesforce with Enterprise Observability Platforms

For enterprises with existing observability infrastructure like Splunk, AWS CloudWatch, or Datadog, integration strategies include:

  • Streaming Event Logs: Using Salesforce Event Monitoring API or Salesforce Shield to pipe logs and user activity into centralized logging platforms in near real-time.

  • API Gateway Monitoring: Capturing Salesforce API usage metrics through integration middleware or API gateways that sit between Salesforce and external systems.

  • Custom Middleware: Building connectors that aggregate error logs, async job states, and performance data from Salesforce REST APIs and push them into enterprise platforms.

  • Alert Correlation: Mapping Salesforce incidents and exceptions into existing alerting workflows for consolidated Root Cause Analysis (RCA).

Recommendations

  • Start with enabling Salesforce native logging and Event Monitoring for the most critical orgs or environments.

  • Build lightweight custom logging in Apex and Flows to capture business-relevant errors and performance data.

  • Leverage your existing observability tools by integrating Salesforce logs and metrics, either via native APIs or middleware.

  • Focus on creating dashboards tailored for Salesforce performance and stability metrics so non-developers can easily spot issues.

  • Prioritize alerting on key exceptions, API limit violations, and slow-running jobs to reduce system downtime and user impact.

  • Periodically review and address technical debt to avoid performance regressions.

Written with Chat GPT

Gary Elbaum
Next

Salesforce has updated several of its certification titles