Taxonomy & Standards

Establishing consistent classification systems and taxonomy standards for Triton logging across your Salesforce org.

Establishing Consistent Classification

Effective logging requires a consistent taxonomy that enables powerful filtering, grouping, and analysis. Triton uses a three-tier classification system: Category, Type, and Area.

Core Taxonomy

Category

Represents the technological origin of the log:

• Apex: Server-side code execution

• Flow: Declarative automation

• LWC: Lightning Web Components

• Integration: External system interactions

• Process Builder: Legacy automation

Type

Refines categorization within the parent category:

• Backend: Server-side processing

• Frontend: Client-side operations

• DMLResult: Database operation results

• Autolaunched Flow: Automated flow execution

• Screen Flow: User-interactive flows

• AccountTrigger: Specific trigger types

Area

Bridges technical and business contexts:

• Accounts: Account-related operations

• Opportunities: Opportunity management

• Leads: Lead processing and conversion

• Cases: Case management

• Orders: Order processing

• Integration: External system interactions

• Community: Experience Cloud operations

Real-World Taxonomy Example

// Extending the taxonomy for your org's specific needs
public class CustomTritonTypes extends TritonTypes {
    // Custom Areas for your business domains
    public enum CustomArea {
        // Financial Services
        LoanProcessing,
        PaymentProcessing,
        RiskAssessment,
        
        // Healthcare
        PatientManagement,
        AppointmentScheduling,
        MedicalRecords,
        
        // Manufacturing
        InventoryManagement,
        QualityControl,
        SupplyChain,
        
        // Retail
        Ecommerce,
        InventoryTracking,
        CustomerService
    }
    
    // Custom Types for specific operations
    public enum CustomType {
        // Integration Types
        REST_API,
        SOAP_API,
        Webhook,
        BatchSync,
        
        // Process Types
        ApprovalWorkflow,
        DataValidation,
        ReportGeneration,
        NotificationService
    }
}

Taxonomy Best Practices

Consistency

• Use established enums: Leverage Triton's built-in taxonomy before creating custom values

• Org-wide standards: Establish and document taxonomy standards across all teams

• Regular reviews: Periodically review and update taxonomy to reflect business changes

• Training: Ensure all developers understand and follow taxonomy standards

Extensibility

• Plan for growth: Design taxonomy to accommodate future business needs

• Hierarchical structure: Use consistent naming patterns for easy understanding

• Documentation: Maintain clear documentation of taxonomy meanings and usage

• Version control: Track taxonomy changes and their impact

Implementation

• Template usage: Use templates to ensure consistent taxonomy application

• Validation: Consider implementing validation to ensure proper taxonomy usage

• Monitoring: Track taxonomy usage to identify patterns and opportunities for improvement

Standards Enforcement

Code Review Checklist

• All logs use appropriate Category/Type/Area combinations

• Custom taxonomy values are documented and justified

• Templates are used consistently for taxonomy application

• No ad-hoc string values are used for classification

Automated Validation

// Example validation utility
public class TaxonomyValidator {
    public static void validateLogTaxonomy(TritonBuilder builder) {
        // Validate category
        if (builder.getCategory() == null) {
            throw new IllegalArgumentException('Category must be specified');
        }
        
        // Validate type
        if (builder.getType() == null) {
            throw new IllegalArgumentException('Type must be specified');
        }
        
        // Validate area
        if (builder.getArea() == null) {
            throw new IllegalArgumentException('Area must be specified');
        }
        
        // Validate custom combinations
        validateCustomCombinations(builder);
    }
    
    private static void validateCustomCombinations(TritonBuilder builder) {
        // Add org-specific validation rules
        if (builder.getCategory() == TritonTypes.Category.Integration && 
            builder.getType() == TritonTypes.Type.Backend) {
            // Integration backend operations should have specific area
            if (builder.getArea() == null) {
                throw new IllegalArgumentException('Integration operations must specify area');
            }
        }
    }
}

Taxonomy Mapping

Business Process Mapping

Map your business processes to taxonomy:

Business Process	Category	Type	Area
Lead Conversion	Apex	Backend	LeadConversion
Payment Processing	Integration	Backend	PaymentProcessing
Customer Portal	LWC	Frontend	Community
Order Fulfillment	Flow	AutolaunchedFlow	OrderProcessing
Data Sync	Apex	Backend	Integration

Technology Mapping

Map technologies to taxonomy:

Technology	Category	Type	Common Areas
Apex Triggers	Apex	Backend	Accounts, Opportunities, Leads
Lightning Components	LWC	Frontend	Community, UserInterface
Process Builder	Process Builder	Backend	Workflow, Notifications
REST APIs	Integration	Backend	ExternalAPI, DataSync
Scheduled Jobs	Apex	Backend	Maintenance, DataProcessing

Custom Taxonomy Development

When to Extend

• New business domains: When entering new markets or business areas

• Technology changes: When adopting new Salesforce technologies

• Process evolution: When business processes change significantly

• Compliance requirements: When new regulatory requirements emerge

Extension Process

1. Identify need: Document why new taxonomy is required

2. Design structure: Plan the new taxonomy values and relationships

3. Review and approve: Get stakeholder approval for taxonomy changes

4. Implement: Add new taxonomy values to code

5. Document: Update documentation and training materials

6. Monitor: Track usage and effectiveness of new taxonomy

Example Extension

// Adding healthcare-specific taxonomy
public class HealthcareTritonTypes extends TritonTypes {
    public enum HealthcareArea {
        PatientManagement,
        AppointmentScheduling,
        MedicalRecords,
        Billing,
        Insurance,
        Compliance
    }
    
    public enum HealthcareType {
        ClinicalWorkflow,
        RegulatoryReporting,
        PatientPortal,
        InsuranceIntegration,
        ComplianceAudit
    }
}

Taxonomy Governance

Ownership

• Central team: Establish a central team responsible for taxonomy governance

• Stakeholder input: Include representatives from all major business areas

• Regular reviews: Schedule periodic reviews of taxonomy effectiveness

• Change management: Establish process for taxonomy changes

Documentation

• Taxonomy guide: Maintain comprehensive documentation of all taxonomy values

• Usage examples: Provide examples of proper taxonomy usage

• Best practices: Document taxonomy best practices and anti-patterns

• Training materials: Create training materials for new team members

Monitoring

• Usage tracking: Monitor how taxonomy is being used across the org

• Effectiveness metrics: Measure the effectiveness of taxonomy for filtering and analysis

• Feedback collection: Gather feedback from users about taxonomy effectiveness

• Continuous improvement: Use metrics and feedback to improve taxonomy

By establishing and maintaining a consistent taxonomy, you'll enable powerful log analysis, filtering, and correlation capabilities that provide lasting value for your organization.