# Pharos Triton

## Pharos Triton 2.0

- [About Pharos Triton](https://triton.pharos.ai/readme.md): Just as the mighty Triton delivered important messages from the deep, Pharos Triton sends you crucial insights from the depths of your Salesforce automation.
- [Installing Pharos Triton](https://triton.pharos.ai/installing-pharos-triton.md): Your journey into logging starts here! This article details how to set up the Pharos Triton tools so you can incorporate logging into your own code base.
- [Core Concepts](https://triton.pharos.ai/core-concepts.md): The mental model behind Pharos Triton — how the static logger, builder, templates, buffering, and transactions fit together before you write any logging code.
- [The Static Logging API](https://triton.pharos.ai/core-concepts/static-logging-api.md): How Triton 2.0's static, builder-first API works — log methods, immediate vs buffered logging, level shorthands, and the transaction state kept for you.
- [The Builder & Templates](https://triton.pharos.ai/core-concepts/builder-and-templates.md): The TritonBuilder fluent API and the template pattern — how to describe a log, stamp shared fields onto every log, and keep your logging code DRY.
- [Log Levels](https://triton.pharos.ai/core-concepts/log-levels.md): How Triton log levels work — the severity scale, choosing the right level, and tuning verbosity per environment with Log\_Level\_\_mdt instead of code changes.
- [Buffering, Flushing & Deferred Publishing](https://triton.pharos.ai/core-concepts/buffering-flushing.md): How Triton buffers logs and publishes them as platform events — flush, flushTop, and drain, and why bulkification matters for platform-event limits.
- [Enums](https://triton.pharos.ai/core-concepts/enums.md): The Category, Type, and Area enums in TritonTypes — what each one classifies, the values that ship out of the box, and how to extend them for your own org.
- [Migrating from 1.x](https://triton.pharos.ai/migration.md): Move your Apex from the Triton 1.x singleton to the 2.0 static, builder-first API — the method-by-method mapping and the one behavioral gotcha to audit.
- [Logging in Apex](https://triton.pharos.ai/common-apex-usage-patters.md): The everyday Apex logging patterns — a first log, grouping logs under a transaction, and the try/catch/finally shape you'll reach for again and again.
- [Batch Logging](https://triton.pharos.ai/common-apex-usage-patters/batch-logging.md): Logging in Batch Apex — where to flush, why each execute() is its own transaction, and how to group every iteration under a single parent log.
- [Performance Marks](https://triton.pharos.ai/common-apex-usage-patters/performance-marks.md): Time any stretch of Apex with startMark / endMark — names derived from the stack trace, automatic nesting, and every log inside the mark parented to it.
- [Integration Logs](https://triton.pharos.ai/common-apex-usage-patters/integration-logs.md): Capture the full request/response payload on an outbound callout so a failed integration is something you can inspect — and replay — instead of guess at.
- [Apex REST Logging](https://triton.pharos.ai/common-apex-usage-patters/apex-rest-logging.md): Logging an inbound REST request at your custom Apex endpoint — capture the payload, open a transaction, and thread its id through everything downstream.
- [Full Control with TritonBuilder](https://triton.pharos.ai/common-apex-usage-patters/full-control-with-tritonbuilder.md): The complete TritonBuilder surface — every method worth knowing, the deep-dive helpers, custom attributes, and the template pattern in full.
- [Log Levels](https://triton.pharos.ai/common-apex-usage-patters/log-levels.md): Choosing the right log level in Apex — the severity scale, the shorthand methods, and tuning verbosity per environment with metadata instead of code changes.
- [Logging in LWC](https://triton.pharos.ai/beyond-apex.md): Logging from Lightning Web Components — the JavaScript Triton API, transaction management, correlating LWC with Apex, and profiling component performance.
- [LWC](https://triton.pharos.ai/beyond-apex/lwc.md): Logging from Lightning Web Components — binding the logger, the fluent builder, buffered vs. immediate logging, and component-scoped templates.
- [LWC Transaction Management](https://triton.pharos.ai/beyond-apex/lwctransaction.md): How Triton manages transactions in LWC — automatic ids, session-storage continuity across components, the auto-flush monitor, and when to take manual control.
- [LWC and Apex](https://triton.pharos.ai/beyond-apex/lwc-and-apex.md): Correlate a front-end action with the Apex it triggers — pass the transaction id from LWC into your controller so UI logs and server logs land in one trace.
- [Platform Cache for Transactions](https://triton.pharos.ai/beyond-apex/lwc-and-apex-cache.md): Use Salesforce Platform Cache to share a transaction id across contexts — correlate LWC and Apex logs without passing the id by hand.
- [Profiling](https://triton.pharos.ai/beyond-apex/profiling.md): Capture performance telemetry from LWC components — backend calls, user interactions, render cycles, and custom marks — with Triton's built-in profiling APIs.
- [Backend Calls](https://triton.pharos.ai/beyond-apex/profiling/backend-calls.md): Wrap Apex calls in timeBackendCall(...) to capture durations, start/complete events, and exceptions — with four flexible error-handling scenarios.
- [User Interactions](https://triton.pharos.ai/beyond-apex/profiling/user-interactions.md): Time user-driven flows — form submissions, multi-step actions, and nested backend calls — with timeUserInteraction(...) and the unified PerformanceCallBuilder.
- [Component Lifecycle](https://triton.pharos.ai/beyond-apex/profiling/component-lifecycle.md): Track LWC mount/unmount events and render counts with per-instance isolation, Locker Service-safe timing, and zero-effort multi-instance support.
- [Custom Performance Marks](https://triton.pharos.ai/beyond-apex/profiling/custom-marks.md): Drop browser-style performance marks anywhere in your LWC code with startPerformanceMark / endPerformanceMark — fully per-instance and Locker Service-safe.
- [Logging in Flow](https://triton.pharos.ai/flows.md): Add structured logging to Salesforce Flows with Triton's invocable Log action — no code required, with deferred batching to protect your platform-event budget.
- [End-to-End Logging](https://triton.pharos.ai/end-to-end.md): How Triton stitches one user action — starting in an LWC, hopping into Apex, and fanning out into a Flow — into a single correlated trace.
- [Transactions & Platform Cache](https://triton.pharos.ai/end-to-end/transactions-and-cache.md): How a transaction id ties logs together across LWC, Apex, and Flow — the lifecycle methods that manage it and the platform cache that moves it between contexts.
- [Spans & Distributed Tracing](https://triton.pharos.ai/end-to-end/spans-and-tracing.md): How Triton builds a parent-child trace out of spans — one level deeper than the transaction id, recording which work happened inside which.
- [Instrumentation Skills](https://triton.pharos.ai/instrumentation-skills.md): Agent-agnostic skills that add production-grade Triton instrumentation to Apex, LWC, and Flows — one file or a whole org — with a human-reviewed diff first.
- [Instrument Apex](https://triton.pharos.ai/instrumentation-skills/instrument-apex.md): The instrument-apex skill adds Triton logging to an Apex class or trigger — transactions, catch blocks, DML and callout payloads — then optionally deploys it.
- [Instrument LWC](https://triton.pharos.ai/instrumentation-skills/instrument-lwc.md): The instrument-lwc skill adds Triton logging to a Lightning Web Component — timed backend calls with span context and transaction stitching to Apex.
- [Instrument Flows](https://triton.pharos.ai/instrumentation-skills/instrument-flows.md): The instrument-flows skill inserts Triton Log actions into a Flow's metadata XML at entry, fault paths, and record operations, then optionally deploys it.
- [Instrument the Org](https://triton.pharos.ai/instrumentation-skills/instrument-org.md): The instrument-org skill runs the Apex, LWC, and Flow skills across a Salesforce project — inventory, prioritize, instrument, deploy — in reviewed batches.
- [Audit Logging Coverage](https://triton.pharos.ai/instrumentation-skills/audit-logging.md): The audit-logging skill scans a Salesforce project read-only, reports where Triton logging is missing or wrong, and produces a prioritized rollout plan.
- [Migrate to 2.0](https://triton.pharos.ai/instrumentation-skills/migrate-to-2.0.md): The migrate-to-2.0 skill rewrites 1.x Triton.instance code to the 2.0 static API and flags the immediate-vs-buffered publishing gotcha for you to confirm.
- [Set Up Standards](https://triton.pharos.ai/instrumentation-skills/setup-standards.md): The setup-standards skill scaffolds CI checks, a review checklist, and Log\_Level\_\_mdt defaults so Triton instrumentation stays consistent as your org grows.
- [The Triton Instrumentation Agent](https://triton.pharos.ai/instrumentation-skills/instrumentation-agent.md): The whole instrumentation skill catalog behind one portable, agent-agnostic persona you point at a Salesforce org to audit, migrate, instrument, and guard it.
- [Best Practices & Standards](https://triton.pharos.ai/triton-best-practices.md): Opinionated, field-tested standards for rolling out Pharos Triton logging across Apex, LWC, and Flow, and keeping it consistent as your org grows.
- [Core Principles](https://triton.pharos.ai/triton-best-practices/core-principles.md): The handful of ideas that make Triton logging worth having — and a master Do/Don't list you can hand to a new team member on day one.
- [Log Levels: When to Use What](https://triton.pharos.ai/triton-best-practices/log-levels-and-usage.md): Choosing the right log level for each situation — and using Log\_Level\_\_mdt to turn the volume up in a sandbox and down in production without touching code.
- [Templates & the Builder Pattern](https://triton.pharos.ai/triton-best-practices/templates-and-builder-pattern.md): The one habit that keeps logging consistent at scale — set a template per unit of work, then log from Triton.t — plus when to override and the LWC equivalent.
- [Buffering & Flushing](https://triton.pharos.ai/triton-best-practices/buffering-and-flushing.md): The discipline that keeps you under platform-event limits without losing the logs that matter — buffer the routine, publish the critical, flush at boundaries.
- [Transaction Management](https://triton.pharos.ai/triton-best-practices/transaction-management.md): Stitching logs from LWC, Apex, and Flow into a single trace — starting, resuming, and stopping transactions, and passing the id versus using platform cache.
- [Implementation Patterns](https://triton.pharos.ai/triton-best-practices/implementation-patterns.md): Copy-ready logging patterns for the contexts you actually work in — triggers, queueables, batches, REST, schedulers, LWC, and Flow — all on the 2.0 static API.
- [Context & Related Objects](https://triton.pharos.ai/triton-best-practices/context-and-related-objects.md): Making every log carry enough context to debug from — what Triton captures for you automatically, what you should add, and what you must never log.
- [Taxonomy & Standards](https://triton.pharos.ai/triton-best-practices/taxonomy-and-standards.md): Designing a Category / Type / Area vocabulary that scales — what each field is for, the values that ship, and how to extend them without fragmenting your data.
- [Exception Handling](https://triton.pharos.ai/triton-best-practices/exception-handling.md): Turning caught exceptions into actionable, correlated error logs — the one-call pattern, partial-DML results, and when to publish now or create an issue.
- [Standards Enforcement](https://triton.pharos.ai/triton-best-practices/standards-enforcement.md): Keeping logging standards from rotting on a growing team — a short review checklist, CI guardrails for common regressions, and testing that logs get written.
- [Legacy Code Logging Rollout](https://triton.pharos.ai/triton-best-practices/legacy-migration.md): A risk-based strategy for rolling Triton logging into existing, poorly-understood code without breaking what you don't fully understand.
- [Apex](https://triton.pharos.ai/methods-reference/apex-methods-reference.md): This article covers the base Apex methods you'll need to create log records.
- [Triton](https://triton.pharos.ai/methods-reference/apex-methods-reference/triton.md): The Triton class is the static entry point for all logging — builder creation, buffered and immediate logging, transaction management, and log-level filtering.
- [TritonBuilder](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonbuilder.md): The TritonBuilder class provides a comprehensive, fluent API for creating structured log records in Salesforce.
- [TritonTypes](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritontypes.md): This article covers the enums and constants used throughout the Triton logging framework.
- [TritonLwc](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonlwc.md): Documentation for the TritonLwc Apex class that provides core logging functionality for Lightning Web Components.
- [ComponentLog](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonlwc/componentlog.md): Documentation for the ComponentLog wrapper class used to structure and transmit log data from Lightning Web Components.
- [Component](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonlwc/component.md): Documentation for the Component wrapper class used to capture LWC component context information.
- [Error](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonlwc/error.md): Documentation for the Error wrapper class used to capture and structure error information from Lightning Web Components.
- [RuntimeInfo](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonlwc/runtimeinfo.md): Documentation for the RuntimeInfo wrapper class used to capture detailed runtime context and performance metrics from Lightning Web Components.
- [TritonFlow](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonflow.md): Documentation for the TritonFlow Apex class that provides core logging functionality for Flow Builder and Process Builder.
- [FlowLog](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonflow/flowlog.md): Documentation for the FlowLog wrapper class used to structure and transmit log data from Flow Builder and Process Builder.
- [TritonFlowFlushBatch](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonflowflushbatch.md): Singleton batch that defers and consolidates Flow log publishing to minimize platform event consumption.
- [TritonHelper](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonhelper.md): The TritonHelper class provides utility methods and builder classes for the Triton logging framework.
- [PostProcessingControlsBuilder](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritonhelper/postprocessingcontrolsbuilder.md): A builder in TritonHelper.cls for setting the post-processing flags that control what Pharos does with a log after it is saved.
- [TritonCacheManager](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritoncachemanager.md): Centralizes Triton's Salesforce Platform Cache (Org cache) operations, with a test-friendly mock backend.
- [TritonTestFactory](https://triton.pharos.ai/methods-reference/apex-methods-reference/tritontestfactory.md): Shared @IsTest helper for setting up, building, flushing, and asserting Triton logs in your own test classes.
- [LogBuilder](https://triton.pharos.ai/methods-reference/apex-methods-reference/logbuilder.md): Triton utilizes the builder design pattern to enable a quick and easy-to-read log creation routine.
- [LWC](https://triton.pharos.ai/methods-reference/lwc.md)
- [Triton](https://triton.pharos.ai/methods-reference/lwc/triton.md)
- [TritonBuilder](https://triton.pharos.ai/methods-reference/lwc/tritonbuilder.md)
- [TritonUtils](https://triton.pharos.ai/methods-reference/lwc/tritonutils.md)
- [2.0](https://triton.pharos.ai/release-notes/2.0.md): Release notes for Pharos Triton 2.0 — a breaking release with a static, builder-first API, distributed tracing with spans, and Apex performance marks.
- [1.42](https://triton.pharos.ai/release-notes/1.42.md): Release notes for Pharos Triton 1.42 — LWC performance tracking, Apex governor-limit tracking, full Jest coverage, and Log\_\_c metadata fixes.
- [Help and Support](https://triton.pharos.ai/help-and-support.md): Instructions for getting support on Pharos or Triton.

## Pharos Triton 1.42

- [About Pharos Triton](https://triton.pharos.ai/1-42/readme.md): Just as the mighty Triton delivered important messages from the deep, Pharos Triton sends you crucial insights from the depths of your Salesforce automation.
- [Installing Pharos Triton](https://triton.pharos.ai/1-42/installing-pharos-triton.md): Your journey into logging starts here! This article details how to set up the Pharos Triton tools so you can incorporate logging into your own code base.
- [Apex Logging Basics](https://triton.pharos.ai/1-42/apex-logging-basics.md): This articles explains the structure and some of the basic principles behind Pharos Triton.
- [Common Apex Usage Patters](https://triton.pharos.ai/1-42/common-apex-usage-patters.md): This articles details of some of the more common logging patterns.
- [Batch Logging](https://triton.pharos.ai/1-42/common-apex-usage-patters/batch-logging.md): This article demonstrates some common approaches to batch logging.
- [Integration Logs](https://triton.pharos.ai/1-42/common-apex-usage-patters/integration-logs.md): If your Salesforce instance is talking to external services via REST or other types of APIs, Pharos Triton can perform a certain type of logging that helps troubleshoot those integrations.
- [Apex Rest Logging](https://triton.pharos.ai/1-42/common-apex-usage-patters/apex-rest-logging.md)
- [Full Control with TritonBuilder](https://triton.pharos.ai/1-42/common-apex-usage-patters/full-control-with-tritonbuilder.md): With TritonBuilder, logging is no longer a tedious task but an art form. Embrace the power of structured logging and let TritonBuilder be your guide. Happy logging!
- [Log Levels](https://triton.pharos.ai/1-42/common-apex-usage-patters/log-levels.md): This article explains how log levels work in Triton and how to configure them using custom metadata.
- [Beyond Apex](https://triton.pharos.ai/1-42/beyond-apex.md): In this series of articles we'll cover more advanced logging scenarios that extend beyond Apex code.
- [LWC](https://triton.pharos.ai/1-42/beyond-apex/lwc.md): In this article we'll take a look at logging in LWC components and familiarize ourselves with Triton's JS interface.
- [LWC Transaction Management](https://triton.pharos.ai/1-42/beyond-apex/lwctransaction.md): Learn how Triton manages LWC transactions and logging sessions, including automatic transaction management and best practices.
- [LWC and Apex](https://triton.pharos.ai/1-42/beyond-apex/lwc-and-apex.md): In this article we'll describe the process for logging in LWC in conjunction with Apex. We will examine how Triton associates two different types of logs together under a single umbrella.
- [Platform Cache for Transactions](https://triton.pharos.ai/1-42/beyond-apex/lwc-and-apex-cache.md): Learn how to use Salesforce Platform Cache with Triton to manage transaction IDs across different contexts without direct parameter passing.
- [Flows](https://triton.pharos.ai/1-42/beyond-apex/flows.md): Flows are a powerful low-code automation tool, and one that is often overlooked by logging frameworks. Let's take a look at how to incorporate Pharos Triton logging into your declarative powerhouse.
- [LWC, Apex and Flows](https://triton.pharos.ai/1-42/beyond-apex/lwc-apex-and-flows.md): In this article we will take a look at a more complex logging scenario involving an LWC component, a corresponding Apex controller, and an autolaunched Flow.
- [Profiling](https://triton.pharos.ai/1-42/beyond-apex/profiling.md): Capture rich performance telemetry from your LWC components — backend calls, user interactions, render cycles, and custom marks — using Triton's built-in profiling APIs.
- [Backend Calls](https://triton.pharos.ai/1-42/beyond-apex/profiling/backend-calls.md): Wrap Apex calls in timeBackendCall(...) to capture durations, start/complete events, and exceptions — with four flexible error-handling scenarios.
- [User Interactions](https://triton.pharos.ai/1-42/beyond-apex/profiling/user-interactions.md): Time user-driven flows — form submissions, multi-step actions, and nested backend calls — with timeUserInteraction(...) and the unified PerformanceCallBuilder.
- [Component Lifecycle](https://triton.pharos.ai/1-42/beyond-apex/profiling/component-lifecycle.md): Track LWC mount/unmount events and render counts with per-instance isolation, Locker Service-safe timing, and zero-effort multi-instance support.
- [Custom Performance Marks](https://triton.pharos.ai/1-42/beyond-apex/profiling/custom-marks.md): Drop browser-style performance marks anywhere in your LWC code with startPerformanceMark / endPerformanceMark — fully per-instance and Locker Service-safe.
- [Best Practices & Standards](https://triton.pharos.ai/1-42/triton-best-practices.md): Comprehensive best practices and standards for implementing Pharos Triton logging across Salesforce Apex, LWC, and Flow with real-world examples and practical guidance.
- [Core Principles](https://triton.pharos.ai/1-42/triton-best-practices/core-principles.md): Understanding the foundational goals and principles of effective Triton logging implementation across Salesforce technologies.
- [Log Levels: When to Use What](https://triton.pharos.ai/1-42/triton-best-practices/log-levels-and-usage.md): Understanding when and how to use different log levels appropriately in Triton logging for optimal debugging and monitoring.
- [Templates & the Builder Pattern](https://triton.pharos.ai/1-42/triton-best-practices/templates-and-builder-pattern.md): Leveraging templates and the builder pattern for consistent, maintainable Triton logging across Apex and LWC.
- [Buffering & Flushing](https://triton.pharos.ai/1-42/triton-best-practices/buffering-and-flushing.md): Smart strategies for buffering and flushing logs in Triton for optimal performance and reliability across Apex and LWC.
- [Transaction Management](https://triton.pharos.ai/1-42/triton-best-practices/transaction-management.md): Correlating logs across LWC → Apex → Flow boundaries using transaction management for end-to-end traceability.
- [Implementation Patterns](https://triton.pharos.ai/1-42/triton-best-practices/implementation-patterns.md): Real-world implementation patterns for Triton logging across different Salesforce contexts including triggers, batches, queueables, and flows.
- [Context & Related Objects](https://triton.pharos.ai/1-42/triton-best-practices/context-and-related-objects.md): Maximizing the value of your log data through rich context and related object tracking in Triton logging.
- [Taxonomy & Standards](https://triton.pharos.ai/1-42/triton-best-practices/taxonomy-and-standards.md): Establishing consistent classification systems and taxonomy standards for Triton logging across your Salesforce org.
- [Exception Handling](https://triton.pharos.ai/1-42/triton-best-practices/exception-handling.md): Best practices for error logging and debugging with Triton, including exception handling patterns and debugging strategies.
- [Standards Enforcement](https://triton.pharos.ai/1-42/triton-best-practices/standards-enforcement.md): Code review checklists and CI automation for enforcing Triton logging standards across your Salesforce org.
- [Legacy Code Logging Rollout](https://triton.pharos.ai/1-42/triton-best-practices/legacy-migration.md): Strategies for rolling out Triton logging in existing Salesforce orgs with legacy automation and code, addressing the challenges of working with undocumented and poorly understood systems.
- [Apex](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference.md): This article covers the base Apex methods you'll need to create log records.
- [Triton](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/triton.md): This article covers all the logging methods, including transaction management and DML result logging.
- [TritonBuilder](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonbuilder.md): The TritonBuilder class provides a comprehensive and flexible API for creating structured log records in Salesforce.
- [TritonTypes](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritontypes.md): This article covers the enums and constants used throughout the Triton logging framework.
- [TritonLwc](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonlwc.md): Documentation for the TritonLwc Apex class that provides core logging functionality for Lightning Web Components.
- [ComponentLog](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonlwc/componentlog.md): Documentation for the ComponentLog wrapper class used to structure and transmit log data from Lightning Web Components.
- [Component](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonlwc/component.md): Documentation for the Component wrapper class used to capture LWC component context information.
- [Error](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonlwc/error.md): Documentation for the Error wrapper class used to capture and structure error information from Lightning Web Components.
- [RuntimeInfo](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonlwc/runtimeinfo.md): Documentation for the RuntimeInfo wrapper class used to capture detailed runtime context and performance metrics from Lightning Web Components.
- [TritonFlow](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonflow.md): Documentation for the TritonFlow Apex class that provides core logging functionality for Flow Builder and Process Builder.
- [FlowLog](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonflow/flowlog.md): Documentation for the FlowLog wrapper class used to structure and transmit log data from Flow Builder and Process Builder.
- [TritonHelper](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonhelper.md): The TritonHelper class provides utility methods and builder classes for the Triton logging framework.
- [PostProcessingControlsBuilder](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/tritonhelper/postprocessingcontrolsbuilder.md): This builder class provides a quick and easy way to set post processing flags. It can be found inside the TritonTypes.cls. These flags determine what type of post processing Pharos performs for a log
- [LogBuilder](https://triton.pharos.ai/1-42/methods-reference/apex-methods-reference/logbuilder.md): Triton utilizes the builder design pattern to enable a quick and easy-to-read log creation routine.
- [LWC](https://triton.pharos.ai/1-42/methods-reference/lwc.md)
- [Triton](https://triton.pharos.ai/1-42/methods-reference/lwc/triton.md)
- [TritonBuilder](https://triton.pharos.ai/1-42/methods-reference/lwc/tritonbuilder.md)
- [TritonUtils](https://triton.pharos.ai/1-42/methods-reference/lwc/tritonutils.md)
- [Release Notes](https://triton.pharos.ai/1-42/release-notes/release-notes.md): Notable changes in each Pharos Triton release — new features, fixes, and upgrade guidance.
- [1.42](https://triton.pharos.ai/1-42/release-notes/release-notes/1.42.md): Release notes for Pharos Triton 1.42 — LWC performance tracking, Apex governor-limit tracking, full Jest coverage, and Log\_\_c metadata fixes.
- [Help and Support](https://triton.pharos.ai/1-42/help-and-support.md): Instructions for getting support on Pharos or Triton.