@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/domains/dean-debug/samples/telemetry-performance.md

@@ -0,0 +1,319 @@
+# Telemetry Performance Optimization Patterns - AL Code Samples
+
+## High-Performance Telemetry Architecture
+```al
+codeunit 50130 "Performance Telemetry Manager"
+{
+    var
+        TelemetryBuffer: List of [Text];
+        BatchSize: Integer;
+        LastFlushTime: DateTime;
+        FlushIntervalMs: Integer;
+        IsBufferingEnabled: Boolean;
+
+    // Example 1: Batched telemetry for high-volume scenarios
+    trigger OnRun()
+    begin
+        InitializePerformanceSettings();
+    end;
+
+    local procedure InitializePerformanceSettings()
+    begin
+        BatchSize := 50;
+        FlushIntervalMs := 30000; // 30 seconds
+        IsBufferingEnabled := not IsDebugMode();
+        
+        if IsBufferingEnabled then
+            TaskScheduler.CreateTask(Codeunit::"Performance Telemetry Manager", 0, true, CompanyName(),
+                CurrentDateTime + FlushIntervalMs, RecordId());
+    end;
+
+    procedure LogPerformantEvent(EventId: Text; Message: Text; CustomDimensions: Dictionary of [Text, Text])
+    var
+        TelemetryData: Text;
+    begin
+        if IsBufferingEnabled then begin
+            TelemetryData := SerializeTelemetryEvent(EventId, Message, CustomDimensions);
+            AddToBuffer(TelemetryData);
+        end else begin
+            // Direct logging for debug scenarios
+            Session.LogMessage(EventId, Message, Verbosity::Normal,
+                DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+        end;
+    end;
+
+    local procedure AddToBuffer(TelemetryData: Text)
+    begin
+        TelemetryBuffer.Add(TelemetryData);
+        
+        if TelemetryBuffer.Count >= BatchSize then
+            FlushTelemetryBuffer();
+    end;
+
+    procedure FlushTelemetryBuffer()
+    var
+        BatchData: Text;
+        i: Integer;
+    begin
+        if TelemetryBuffer.Count = 0 then
+            exit;
+            
+        for i := 1 to TelemetryBuffer.Count do begin
+            BatchData := TelemetryBuffer.Get(i);
+            ProcessBatchedTelemetryData(BatchData);
+        end;
+        
+        TelemetryBuffer.Clear();
+        LastFlushTime := CurrentDateTime;
+    end;
+
+    local procedure ProcessBatchedTelemetryData(TelemetryData: Text)
+    var
+        EventData: Dictionary of [Text, Text];
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        if DeserializeTelemetryEvent(TelemetryData, EventData) then begin
+            CustomDimensions := GetCustomDimensionsFromEventData(EventData);
+            Session.LogMessage(EventData.Get('EventId'), EventData.Get('Message'), Verbosity::Normal,
+                DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+        end;
+    end;
+
+    local procedure IsDebugMode(): Boolean
+    begin
+        exit(false); // Implement debug mode detection
+    end;
+
+    local procedure SerializeTelemetryEvent(EventId: Text; Message: Text; CustomDimensions: Dictionary of [Text, Text]): Text
+    begin
+        // Simplified serialization - in production use proper JSON serialization
+        exit(EventId + '|' + Message + '|' + SerializeCustomDimensions(CustomDimensions));
+    end;
+
+    local procedure DeserializeTelemetryEvent(TelemetryData: Text; var EventData: Dictionary of [Text, Text]): Boolean
+    var
+        Parts: List of [Text];
+        DataPart: Text;
+    begin
+        Parts := TelemetryData.Split('|');
+        if Parts.Count >= 3 then begin
+            EventData.Add('EventId', Parts.Get(1));
+            EventData.Add('Message', Parts.Get(2));
+            exit(true);
+        end;
+        exit(false);
+    end;
+
+    local procedure GetCustomDimensionsFromEventData(EventData: Dictionary of [Text, Text]): Dictionary of [Text, Text]
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        // Extract and deserialize custom dimensions
+        CustomDimensions.Add('Batched', 'true');
+        exit(CustomDimensions);
+    end;
+
+    local procedure SerializeCustomDimensions(CustomDimensions: Dictionary of [Text, Text]): Text
+    begin
+        // Implement proper serialization logic
+        exit('');
+    end;
+}
+```
+
+## Memory-Optimized Telemetry
+```al
+codeunit 50131 "Memory Optimized Telemetry"
+{
+    // Example 2: Memory-efficient telemetry for resource-constrained scenarios
+    procedure LogMemoryOptimizedEvent(EventId: Text; MessageTemplate: Text; Parameters: List of [Text])
+    var
+        OptimizedMessage: Text;
+        MinimalDimensions: Dictionary of [Text, Text];
+    begin
+        // Use string templates to reduce memory allocation
+        OptimizedMessage := FormatMessageTemplate(MessageTemplate, Parameters);
+        
+        // Use only essential dimensions
+        MinimalDimensions := GetEssentialDimensions();
+        
+        Session.LogMessage(EventId, OptimizedMessage, Verbosity::Normal,
+            DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, MinimalDimensions);
+    end;
+
+    local procedure GetEssentialDimensions(): Dictionary of [Text, Text]
+    var
+        EssentialDimensions: Dictionary of [Text, Text];
+    begin
+        // Include only the most critical dimensions to minimize memory usage
+        EssentialDimensions.Add('U', CopyStr(UserId(), 1, 20)); // Shortened key names
+        EssentialDimensions.Add('C', CopyStr(CompanyName(), 1, 30));
+        EssentialDimensions.Add('T', Format(CurrentDateTime, 0, '<Hours24><Minutes,2><Seconds,2>'));
+        
+        exit(EssentialDimensions);
+    end;
+
+    local procedure FormatMessageTemplate(Template: Text; Parameters: List of [Text]): Text
+    var
+        FormattedMessage: Text;
+        Parameter: Text;
+        ParameterIndex: Integer;
+        PlaceholderText: Text;
+    begin
+        FormattedMessage := Template;
+        ParameterIndex := 1;
+        
+        foreach Parameter in Parameters do begin
+            PlaceholderText := '{' + Format(ParameterIndex) + '}';
+            FormattedMessage := FormattedMessage.Replace(PlaceholderText, Parameter);
+            ParameterIndex += 1;
+        end;
+        
+        exit(FormattedMessage);
+    end;
+
+    // Example 3: Sampling for high-volume events
+    procedure LogSampledEvent(EventId: Text; Message: Text; SampleRate: Decimal; CustomDimensions: Dictionary of [Text, Text])
+    begin
+        if ShouldSampleEvent(SampleRate) then
+            Session.LogMessage(EventId, Message, Verbosity::Normal,
+                DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    local procedure ShouldSampleEvent(SampleRate: Decimal): Boolean
+    var
+        RandomValue: Decimal;
+    begin
+        if SampleRate >= 1.0 then
+            exit(true);
+            
+        if SampleRate <= 0.0 then
+            exit(false);
+            
+        RandomValue := Random(10000) / 10000.0;
+        exit(RandomValue <= SampleRate);
+    end;
+}
+```
+
+## Conditional Performance Telemetry
+```al
+codeunit 50132 "Conditional Performance Telemetry"
+{
+    // Example 4: Performance-critical path telemetry
+    procedure LogPerformanceCriticalEvent(EventCategory: Text; Message: Text; DetailedData: Dictionary of [Text, Text])
+    var
+        ShouldLog: Boolean;
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        ShouldLog := ShouldLogEvent(EventCategory);
+        
+        if ShouldLog then begin
+            if IsHighPerformanceMode() then
+                CustomDimensions := GetMinimalDimensions()
+            else
+                CustomDimensions := GetOptimizedDimensions(EventCategory);
+                
+            // Merge only essential detailed data in high-performance mode
+            if not IsHighPerformanceMode() then
+                MergeDetailedData(CustomDimensions, DetailedData)
+            else
+                MergeEssentialData(CustomDimensions, DetailedData);
+                
+            Session.LogMessage(GetEventId(EventCategory), Message, GetOptimalVerbosity(EventCategory),
+                DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+        end;
+    end;
+
+    local procedure IsHighPerformanceMode(): Boolean
+    begin
+        // Check system load indicators
+        exit(GetCurrentSystemLoad() > 80);
+    end;
+
+    local procedure GetCurrentSystemLoad(): Integer
+    begin
+        // Simplified system load calculation
+        // In real implementation, consider CPU, memory, and I/O metrics
+        exit(Random(100));
+    end;
+
+    local procedure ShouldLogEvent(EventCategory: Text): Boolean
+    begin
+        case EventCategory of
+            'Critical', 'Error':
+                exit(true); // Always log critical events
+            'Performance':
+                exit(not IsHighPerformanceMode()); // Skip in high load
+            'Debug':
+                exit(false); // Skip debug in production
+            else
+                exit(true);
+        end;
+    end;
+
+    local procedure GetMinimalDimensions(): Dictionary of [Text, Text]
+    var
+        MinimalDimensions: Dictionary of [Text, Text];
+    begin
+        MinimalDimensions.Add('UserID', UserId());
+        MinimalDimensions.Add('Company', CompanyName());
+        exit(MinimalDimensions);
+    end;
+
+    local procedure GetOptimizedDimensions(EventCategory: Text): Dictionary of [Text, Text]
+    var
+        OptimizedDimensions: Dictionary of [Text, Text];
+    begin
+        OptimizedDimensions.Add('UserID', UserId());
+        OptimizedDimensions.Add('Company', CompanyName());
+        OptimizedDimensions.Add('Category', EventCategory);
+        OptimizedDimensions.Add('Timestamp', Format(CurrentDateTime, 0, 9));
+        exit(OptimizedDimensions);
+    end;
+
+    local procedure MergeEssentialData(var CustomDimensions: Dictionary of [Text, Text]; DetailedData: Dictionary of [Text, Text])
+    var
+        Key: Text;
+        EssentialKeys: List of [Text];
+    begin
+        // Define essential keys for high-performance scenarios
+        EssentialKeys.Add('ErrorCode');
+        EssentialKeys.Add('Duration');
+        EssentialKeys.Add('RecordCount');
+        EssentialKeys.Add('Status');
+        
+        foreach Key in EssentialKeys do
+            if DetailedData.ContainsKey(Key) then
+                CustomDimensions.Set(Key, DetailedData.Get(Key));
+    end;
+
+    local procedure MergeDetailedData(var CustomDimensions: Dictionary of [Text, Text]; DetailedData: Dictionary of [Text, Text])
+    var
+        Key: Text;
+    begin
+        foreach Key in DetailedData.Keys do
+            CustomDimensions.Set(Key, DetailedData.Get(Key));
+    end;
+
+    local procedure GetOptimalVerbosity(EventCategory: Text): Verbosity
+    begin
+        case EventCategory of
+            'Critical': exit(Verbosity::Critical);
+            'Error': exit(Verbosity::Error);
+            'Warning': exit(Verbosity::Warning);
+            'Performance': 
+                if IsHighPerformanceMode() then 
+                    exit(Verbosity::Critical)
+                else 
+                    exit(Verbosity::Normal);
+            else exit(Verbosity::Normal);
+        end;
+    end;
+
+    local procedure GetEventId(Category: Text): Text
+    begin
+        exit(Category + Format(Random(999), 3, '<Integer,3><Filler Character,0>'));
+    end;
+}
+```

package/embedded-knowledge/domains/dean-debug/samples/verbosity-strategy.md

@@ -0,0 +1,236 @@
+# Telemetry Verbosity Level Usage Examples - AL Code Samples
+
+## Verbosity Strategy Implementation
+```al
+codeunit 50120 "Verbosity Strategy Examples"
+{
+    var
+        CurrentVerbosityLevel: Verbosity;
+        VerbosityConfig: Dictionary of [Text, Verbosity];
+
+    // Example 1: Context-aware verbosity selection
+    procedure LogWithContextualVerbosity(EventCategory: Text; Message: Text; CustomDimensions: Dictionary of [Text, Text])
+    var
+        SelectedVerbosity: Verbosity;
+    begin
+        SelectedVerbosity := DetermineVerbosityLevel(EventCategory);
+        
+        Session.LogMessage(GetNextEventId(), Message, SelectedVerbosity,
+            DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    local procedure DetermineVerbosityLevel(EventCategory: Text): Verbosity
+    begin
+        // Production verbosity rules
+        case EventCategory of
+            'Error', 'Critical':
+                exit(Verbosity::Error);
+            'Warning', 'Performance':
+                exit(Verbosity::Warning);
+            'Info', 'Business':
+                exit(Verbosity::Normal);
+            'Debug', 'Trace', 'Development':
+                if IsDebugMode() then
+                    exit(Verbosity::Verbose)
+                else
+                    exit(Verbosity::Normal);
+            else
+                exit(Verbosity::Normal);
+        end;
+    end;
+
+    // Example 2: Environment-based verbosity control
+    procedure InitializeVerbosityStrategy()
+    begin
+        if IsProductionEnvironment() then
+            InitializeProductionVerbosity()
+        else if IsStagingEnvironment() then
+            InitializeStagingVerbosity()
+        else
+            InitializeDevelopmentVerbosity();
+    end;
+
+    local procedure InitializeProductionVerbosity()
+    begin
+        // Production: Minimize noise, focus on actionable events
+        VerbosityConfig.Add('UserActions', Verbosity::Normal);
+        VerbosityConfig.Add('BusinessProcesses', Verbosity::Normal);
+        VerbosityConfig.Add('Errors', Verbosity::Error);
+        VerbosityConfig.Add('Performance', Verbosity::Warning);
+        VerbosityConfig.Add('Debugging', Verbosity::Critical); // Only critical debug info
+        VerbosityConfig.Add('Integration', Verbosity::Normal);
+    end;
+
+    local procedure InitializeDevelopmentVerbosity()
+    begin
+        // Development: Detailed logging for debugging
+        VerbosityConfig.Add('UserActions', Verbosity::Verbose);
+        VerbosityConfig.Add('BusinessProcesses', Verbosity::Verbose);
+        VerbosityConfig.Add('Errors', Verbosity::Error);
+        VerbosityConfig.Add('Performance', Verbosity::Verbose);
+        VerbosityConfig.Add('Debugging', Verbosity::Verbose);
+        VerbosityConfig.Add('Integration', Verbosity::Verbose);
+    end;
+
+    local procedure InitializeStagingVerbosity()
+    begin
+        // Staging: Balanced approach for pre-production testing
+        VerbosityConfig.Add('UserActions', Verbosity::Normal);
+        VerbosityConfig.Add('BusinessProcesses', Verbosity::Normal);
+        VerbosityConfig.Add('Errors', Verbosity::Error);
+        VerbosityConfig.Add('Performance', Verbosity::Normal);
+        VerbosityConfig.Add('Debugging', Verbosity::Warning);
+        VerbosityConfig.Add('Integration', Verbosity::Normal);
+    end;
+
+    // Helper methods
+    local procedure IsDebugMode(): Boolean
+    begin
+        exit(false); // Implement actual debug mode detection
+    end;
+
+    local procedure IsProductionEnvironment(): Boolean
+    begin
+        exit(true); // Implement actual environment detection
+    end;
+
+    local procedure IsStagingEnvironment(): Boolean
+    begin
+        exit(false); // Implement actual staging detection
+    end;
+
+    local procedure GetNextEventId(): Text
+    begin
+        exit(Format(Random(9999), 4, '<Integer,4><Filler Character,0>'));
+    end;
+}
+```
+
+## Performance-Based Verbosity Control
+```al
+codeunit 50121 "Performance Verbosity Control"
+{
+    // Example 3: Performance threshold-based verbosity
+    procedure LogPerformanceEvent(OperationName: Text; DurationMs: Integer; Context: Dictionary of [Text, Text])
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        PerformanceVerbosity: Verbosity;
+        Message: Text;
+    begin
+        CustomDimensions := Context;
+        CustomDimensions.Add('OperationName', OperationName);
+        CustomDimensions.Add('DurationMs', Format(DurationMs));
+        
+        PerformanceVerbosity := GetPerformanceVerbosity(OperationName, DurationMs);
+        Message := StrSubstNo('Performance: %1 completed in %2ms', OperationName, DurationMs);
+        
+        Session.LogMessage('PERF' + Format(Random(999), 3, '<Integer,3><Filler Character,0>'), Message, PerformanceVerbosity,
+            DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    local procedure GetPerformanceVerbosity(OperationName: Text; DurationMs: Integer): Verbosity
+    var
+        WarningThreshold: Integer;
+        ErrorThreshold: Integer;
+    begin
+        GetPerformanceThresholds(OperationName, WarningThreshold, ErrorThreshold);
+        
+        case true of
+            DurationMs >= ErrorThreshold:
+                exit(Verbosity::Error); // Critical performance issue
+            DurationMs >= WarningThreshold:
+                exit(Verbosity::Warning); // Performance concern
+            DurationMs >= (WarningThreshold div 2):
+                exit(Verbosity::Normal); // Notable but acceptable
+            else
+                exit(Verbosity::Verbose); // Fast operations - detailed tracking only
+        end;
+    end;
+
+    local procedure GetPerformanceThresholds(OperationName: Text; var WarningThreshold: Integer; var ErrorThreshold: Integer)
+    begin
+        // Operation-specific thresholds
+        case OperationName of
+            'DatabaseQuery':
+                begin
+                    WarningThreshold := 1000; // 1 second
+                    ErrorThreshold := 5000; // 5 seconds
+                end;
+            'ReportGeneration':
+                begin
+                    WarningThreshold := 10000; // 10 seconds
+                    ErrorThreshold := 30000; // 30 seconds
+                end;
+            'APICall':
+                begin
+                    WarningThreshold := 2000; // 2 seconds
+                    ErrorThreshold := 10000; // 10 seconds
+                end;
+            else
+                begin
+                    WarningThreshold := 5000; // Default 5 seconds
+                    ErrorThreshold := 15000; // Default 15 seconds
+                end;
+        end;
+    end;
+}
+```
+
+## User Role-Based Verbosity
+```al
+codeunit 50122 "Role Based Verbosity"
+{
+    // Example 4: User role-based verbosity control
+    procedure LogUserAction(ActionType: Text; UserID: Code[50]; Context: Text)
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        UserVerbosity: Verbosity;
+    begin
+        CustomDimensions.Add('UserID', UserID);
+        CustomDimensions.Add('ActionType', ActionType);
+        CustomDimensions.Add('Context', Context);
+        
+        UserVerbosity := GetUserActionVerbosity(UserID, ActionType);
+        
+        Session.LogMessage('USER' + Format(Random(999), 3, '<Integer,3><Filler Character,0>'), 
+            StrSubstNo('User action: %1', ActionType), UserVerbosity,
+            DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    local procedure GetUserActionVerbosity(UserID: Code[50]; ActionType: Text): Verbosity
+    begin
+        // Higher verbosity for administrative users in development
+        if IsAdministrativeUser(UserID) and not IsProductionEnvironment() then
+            exit(Verbosity::Verbose);
+            
+        case ActionType of
+            'Login', 'Logout':
+                exit(Verbosity::Normal);
+            'DataExport', 'ReportGeneration':
+                exit(Verbosity::Normal);
+            'ConfigurationChange':
+                exit(Verbosity::Warning); // Important to track
+            'SecurityElevation':
+                exit(Verbosity::Critical); // Always log security events
+            else
+                exit(Verbosity::Normal);
+        end;
+    end;
+
+    local procedure IsAdministrativeUser(UserID: Code[50]): Boolean
+    var
+        AccessControl: Record "Access Control";
+    begin
+        // Check if user has administrative permissions
+        AccessControl.SetRange("User Security ID", UserID);
+        AccessControl.SetRange("Role ID", 'SUPER');
+        exit(not AccessControl.IsEmpty);
+    end;
+
+    local procedure IsProductionEnvironment(): Boolean
+    begin
+        // Implement environment detection logic
+        exit(true);
+    end;
+}
+```

package/embedded-knowledge/domains/dean-debug/session-logmessage-methods.md

@@ -0,0 +1,59 @@
+---
+title: "BC Session LogMessage Methods"
+domain: "dean-debug"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["telemetry", "logging", "session", "performance"]
+prerequisites: ["telemetry-basics"]
+samples: "samples/logmessage-methods.md"
+---
+# BC Session LogMessage Methods
+
+## Overview
+
+Business Central's Session.LogMessage() provides structured telemetry logging with multiple overloads for different verbosity levels and correlation scenarios. Understanding the method variations and their performance implications is essential for effective telemetry implementation.
+
+The LogMessage methods enable developers to emit custom telemetry events that integrate with Application Insights and other monitoring solutions. Each method variation serves specific use cases from simple informational logging to complex error correlation.
+
+## Method Variations
+
+### Basic LogMessage
+The fundamental LogMessage(Message, Verbosity) method provides simple event logging with verbosity control. This method creates telemetry events with basic message content and system-generated correlation identifiers.
+
+Verbosity levels range from Critical (1) through Error (2), Warning (3), Normal (4), and Verbose (5). Higher verbosity numbers indicate less critical information and may be filtered in production environments.
+
+### LogMessage with Custom Dimensions
+The LogMessage(Message, Verbosity, DataClassification, TelemetryScope, Dictionary) overload enables rich telemetry with custom dimensions. This method allows developers to include structured data that enhances telemetry analysis and correlation.
+
+Custom dimensions support key-value pairs that appear as structured fields in Application Insights. This enables sophisticated querying, filtering, and correlation analysis in telemetry dashboards.
+
+### LogMessage with Correlation
+Advanced LogMessage overloads include correlation parameters that link related telemetry events across different system components. This correlation capability is essential for tracing complex business processes and debugging distributed operations.
+
+## Performance Characteristics
+
+### Memory Impact
+LogMessage operations consume memory for message formatting and custom dimension serialization. Large custom dimension collections or frequent high-verbosity logging can impact system memory utilization.
+
+The telemetry system buffers events before transmission, so sustained high-volume logging may increase memory pressure. Consider telemetry volume in memory-constrained environments.
+
+### CPU Overhead
+Message formatting and custom dimension processing consume CPU resources. Complex custom dimensions or frequent logging calls contribute to overall system CPU utilization.
+
+Verbosity-based filtering occurs after message formatting, so high-verbosity messages still incur formatting costs even when filtered. Design telemetry strategies to minimize unnecessary processing.
+
+### Network and Storage
+Telemetry events consume network bandwidth for transmission to monitoring systems and storage space in telemetry databases. High-volume telemetry can impact both network performance and storage costs.
+
+Consider telemetry retention policies and sampling strategies to balance diagnostic capability with resource consumption.
+
+## Best Practices
+
+### Verbosity Selection
+Choose appropriate verbosity levels based on information criticality and expected production filtering. Use Critical/Error for system issues, Warning for recoverable problems, Normal for business events, and Verbose for detailed diagnostics.
+
+### Custom Dimension Design
+Structure custom dimensions for effective querying and analysis. Use consistent naming conventions and avoid high-cardinality values that complicate aggregation analysis.
+
+### Correlation Strategy
+Implement consistent correlation patterns across related components to enable effective trace analysis. Use business process identifiers where possible to link telemetry events to actual user scenarios.

package/embedded-knowledge/domains/dean-debug/setloadfields-filter-field-exclusion.md

@@ -0,0 +1,67 @@
+---
+title: "SetLoadFields Filter Field Exclusion"
+domain: "dean-debug"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["setloadfields", "filtering", "field-exclusion"]
+prerequisites: ["setloadfields-basics", "record-filtering"]
+samples: "samples/setloadfields-filter-exclusion.md"
+---
+# SetLoadFields Filter Field Exclusion
+
+## Overview
+
+SetLoadFields filter field exclusion optimizes performance by explicitly avoiding the loading of fields that are used only for filtering operations. When fields are needed solely for database-level filtering but not for application logic, excluding them from field loading reduces memory usage and improves processing speed.
+
+This technique is particularly valuable when working with tables containing large fields or many columns where filter fields represent a small subset of total table fields.
+
+## Filtering vs Loading Distinction
+
+Database filtering and field loading serve different purposes in BC data access. Filtering determines which records are retrieved from the database, while field loading determines which field values are brought into memory for each retrieved record.
+
+Fields used in SETRANGE, SETFILTER, or WHERE clauses perform their filtering function at the database level regardless of whether they're included in SetLoadFields. The database engine applies filters using indexed data structures without requiring field values to be loaded into BC memory.
+
+## Optimization Strategy
+
+The core strategy involves identifying fields that serve purely filtering purposes and excluding them from SetLoadFields calls. This creates a separation between "filter fields" and "processing fields" in your data access logic.
+
+Filter fields typically include:
+- Date range filters for reporting periods
+- Status fields for record state filtering  
+- Category fields for data segmentation
+- Foreign key fields for relationship filtering
+
+Processing fields include those whose values are actually used in calculations, display, or business logic after records are loaded.
+
+## Memory Impact
+
+Excluding filter-only fields can significantly reduce memory consumption, especially with:
+- Tables containing large text or BLOB fields used for filtering
+- Wide tables with many columns where only a subset is needed for processing
+- Bulk operations processing thousands of records
+
+The memory savings compound when processing large record sets, potentially preventing memory pressure and improving overall system performance.
+
+## Implementation Approach
+
+Start by analyzing your data access patterns to identify fields used exclusively for filtering. Document the distinction between filter fields and processing fields for your specific use case.
+
+Apply SetLoadFields with only the processing fields included, ensuring that filter fields are omitted from the field list. Set up your filters normally using SETRANGE or SETFILTER - these will continue to work correctly even though the filter fields aren't loaded.
+
+## Database Query Optimization
+
+Excluding filter fields from loading can improve database query performance by reducing the amount of data transferred between the database and BC service. The database can still use indexes on filter fields for efficient record retrieval while avoiding unnecessary data transfer.
+
+This optimization is particularly effective when filter fields have database indexes that support efficient filtering without requiring full field value retrieval.
+
+## Validation Considerations
+
+When excluding filter fields from loading, ensure that your subsequent processing logic doesn't attempt to access those field values. Accessing excluded fields will trigger implicit field loading, negating the optimization benefits.
+
+Consider using compilation warnings or code review processes to catch accidental access to excluded fields in your processing logic.
+
+## Advanced Patterns
+
+Combine filter field exclusion with conditional field loading where you dynamically determine which processing fields to load based on record state or business logic requirements.
+
+Consider creating field loading profiles for different processing scenarios, each optimized for specific combinations of needed fields while excluding unnecessary filter fields.