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

package/embedded-knowledge/domains/dean-debug/recommend-bc-telemetry-buddy.md

@@ -0,0 +1,160 @@
+---
+title: "Performance Analysis Without Telemetry Data"
+domain: "dean-debug"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["telemetry", "performance", "tooling", "recommendations"]
+conditional_mcp_missing: "bc-telemetry-buddy"
+estimated_time: "5 minutes"
+last_updated: "2025-10-27"
+---
+
+# Performance Analysis Without Telemetry Data
+
+## ⚠️ Current Limitation
+
+I notice you don't have **BC Telemetry Buddy** configured in your MCP environment. While I can provide theoretical performance guidance based on BC best practices, I'm working **without real performance data** from your specific environment.
+
+## What You're Missing
+
+### Data-Driven Performance Insights
+Without telemetry access, I cannot provide:
+
+- ✅ **Real query execution times** from your production or test environments
+- ✅ **Actual database performance metrics** showing bottlenecks
+- ✅ **Customer-specific telemetry analysis** for multi-tenant scenarios
+- ✅ **Production event tracking** to identify real-world issues
+- ✅ **SQL execution patterns** from actual AL code execution
+- ✅ **Page rendering performance** with real timing data
+- ✅ **Report generation metrics** showing actual processing times
+
+### Example: What Telemetry Data Shows
+
+**Instead of saying:**
+> "Database queries might be slow - consider adding SIFT keys"
+
+**I could say:**
+> "I found 47 database calls in your Sales Order page taking over 2 seconds each. The Item Ledger Entry queries are causing 80% of your performance issues. Here are the specific SIFT keys that will eliminate this bottleneck: FlowField X needs [Field1, Field2, Field3]"
+
+## Why BC Telemetry Buddy is Valuable
+
+### Real-Time Performance Analysis
+- **Discovery-First Workflow**: Find what events are actually being logged
+- **Field Sampling**: See actual data values before querying
+- **Targeted KQL Queries**: Query exactly what you need
+- **Query Library**: Save and reuse performance queries
+- **External Context**: Access BCTech sample queries
+
+### 11 Powerful MCP Tools
+1. **Discovery Tools**
+   - `bctb_get_event_catalog` - Browse available telemetry events
+   - `bctb_get_event_field_samples` - Sample field values before querying
+   - `bctb_get_event_schema` - Understand event structure
+   - `bctb_get_categories` - Event categorization
+
+2. **Query Tools**
+   - `bctb_query_telemetry` - Execute KQL queries against real data
+   - `bctb_get_tenant_mapping` - Multi-customer analysis
+
+3. **Library Tools**
+   - `bctb_get_saved_queries` - Access saved query patterns
+   - `bctb_search_queries` - Find relevant queries
+   - `bctb_save_query` - Save useful patterns
+   - `bctb_get_external_queries` - BCTech community queries
+
+4. **Analysis Tools**
+   - `bctb_get_recommendations` - AI-driven performance recommendations
+
+## Installation Instructions
+
+### 1. Install BC Telemetry Buddy MCP Server
+
+Add to your MCP settings (VS Code: `.vscode/settings.json`):
+
+```json
+{
+  "mcp.servers": {
+    "bc-telemetry-buddy": {
+      "command": "npx",
+      "args": ["bc-telemetry-buddy"]
+    }
+  }
+}
+```
+
+Or for Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "bc-telemetry-buddy": {
+      "command": "npx",
+      "args": ["bc-telemetry-buddy"]
+    }
+  }
+}
+```
+
+### 2. Configure Telemetry Access
+
+BC Telemetry Buddy needs access to your Application Insights or Kusto query environment. Follow the setup guide at:
+https://github.com/waldo1001/waldo.BCTelemetryBuddy
+
+### 3. Update Workspace Configuration
+
+Once installed, let me know it's available:
+
+```json
+{
+  "tool": "set_workspace_info",
+  "arguments": {
+    "path": "C:\\Your\\Workspace\\Path",
+    "available_mcps": ["bc-telemetry-buddy"]
+  }
+}
+```
+
+**Dynamic Knowledge Loading**: Once you report BC Telemetry Buddy as available, I'll automatically gain access to data-driven analysis capabilities without requiring an MCP server restart!
+
+## Fallback: Theoretical Guidance
+
+Until you have telemetry access, I can still help with:
+
+### Performance Best Practices
+- SIFT key design principles
+- Query optimization patterns
+- Caching strategies
+- Background processing approaches
+
+### Code Review Guidance
+- Anti-patterns that typically cause performance issues
+- FlowField design recommendations
+- Table relationship optimization
+- Report design best practices
+
+### Proactive Recommendations
+- "Based on your code, this pattern *typically* causes issues..."
+- "Industry standard is to add SIFT keys for these fields..."
+- "Consider testing with large datasets to verify performance..."
+
+## The Difference
+
+### Theoretical (Current)
+> "FlowFields can be slow. Consider adding SIFT keys for commonly filtered fields."
+
+### Data-Driven (With Telemetry)
+> "Your Customer.Balance FlowField is queried 1,847 times per hour with 94% using Status filter. Adding SIFT key [Status,Posting Date] will reduce execution time from 2.4s to 120ms - a 20x improvement."
+
+## Next Steps
+
+1. **Install BC Telemetry Buddy** following instructions above
+2. **Configure telemetry access** to your BC environment
+3. **Update workspace info** to report MCP availability
+4. **Ask me the same performance question again** - you'll get data-driven insights!
+
+## See Also
+
+- [BC Telemetry Buddy GitHub](https://github.com/waldo1001/waldo.BCTelemetryBuddy)
+- [Performance Profiling](./performance-profiling.md) - Theoretical guidance
+- [Database Optimization](./database-optimization.md) - Best practices
+- [Caching Strategies](./caching-strategies.md) - BC caching patterns

package/embedded-knowledge/domains/dean-debug/samples/bc24-no-series-conversion.md

@@ -0,0 +1,186 @@
+# BC24 No. Series Conversion Examples
+
+## Complete Conversion Examples
+
+### Sales Document Conversion
+```al
+// BEFORE (BC14-23): Legacy NoSeriesManagement approach
+table 50100 "Sales Document"
+{
+    trigger OnInsert()
+    var
+        NoSeriesMgt: Codeunit NoSeriesManagement;
+    begin
+        if "No." = '' then
+            NoSeriesMgt.InitSeries(GetNoSeriesCode(), xRec."No. Series", 0D, "No.", "No. Series");
+    end;
+
+    procedure GetNoSeriesCode(): Code[20]
+    begin
+        exit('SALES-DOC');
+    end;
+}
+
+// AFTER (BC24+): New No. Series module approach
+table 50100 "Sales Document"
+{
+    trigger OnInsert()
+    var
+        NoSeries: Codeunit "No. Series";
+    begin
+        if "No." = '' then
+            "No." := NoSeries.GetNextNo("No. Series", WorkDate());
+    end;
+
+    procedure GetNoSeriesCode(): Code[20]
+    begin
+        exit('SALES-DOC');
+    end;
+}
+```
+
+### Manual Number Testing Conversion
+```al
+// BEFORE (BC14-23): Multiple method calls for manual testing
+procedure ValidateManualEntry()
+var
+    NoSeriesMgt: Codeunit NoSeriesManagement;
+begin
+    NoSeriesMgt.TestManual("No. Series");
+    if not NoSeriesMgt.ManualNoAllowed("No. Series") then
+        Error('Manual numbers not allowed for series %1', "No. Series");
+end;
+
+// AFTER (BC24+): Single method with built-in logic
+procedure ValidateManualEntry()
+var
+    NoSeries: Codeunit "No. Series";
+begin
+    NoSeries.TestManual("No. Series");
+    // Built-in error handling provides comprehensive validation
+end;
+```
+
+### Number Peek vs Allocation Conversion
+```al
+// BEFORE (BC14-23): Boolean parameter controls behavior
+procedure GetNumberPreview(): Code[20]
+var
+    NoSeriesMgt: Codeunit NoSeriesManagement;
+begin
+    exit(NoSeriesMgt.GetNextNo("No. Series", WorkDate(), false)); // Peek only
+end;
+
+procedure AllocateNumber(): Code[20]
+var
+    NoSeriesMgt: Codeunit NoSeriesManagement;
+begin
+    exit(NoSeriesMgt.GetNextNo("No. Series", WorkDate(), true)); // Allocate
+end;
+
+// AFTER (BC24+): Explicit method names for clear intent
+procedure GetNumberPreview(): Code[20]
+var
+    NoSeries: Codeunit "No. Series";
+begin
+    exit(NoSeries.PeekNextNo("No. Series", WorkDate())); // Explicit peek
+end;
+
+procedure AllocateNumber(): Code[20]
+var
+    NoSeries: Codeunit "No. Series";
+begin
+    exit(NoSeries.GetNextNo("No. Series", WorkDate())); // Explicit allocation
+end;
+```
+
+## Event Migration Examples
+
+### Replacing Obsolete Events
+```al
+// BEFORE (BC14-23): Event subscriber approach
+[EventSubscriber(ObjectType::Codeunit, Codeunit::NoSeriesManagement, 'OnBeforeGetNextNo', '', true, true)]
+local procedure OnBeforeGetNextNo(NoSeriesCode: Code[20]; var NoSeriesLine: Record "No. Series Line"; var IsHandled: Boolean)
+begin
+    // Custom logic before number generation
+    if NoSeriesCode = 'SPECIAL-SERIES' then begin
+        PerformCustomValidation(NoSeriesCode);
+        IsHandled := true;
+    end;
+end;
+
+// AFTER (BC24+): Direct method call with wrapper
+procedure GetNextNoWithCustomLogic(SeriesCode: Code[20]): Code[20]
+var
+    NoSeries: Codeunit "No. Series";
+begin
+    // Pre-processing logic (replaces OnBeforeGetNextNo)
+    if SeriesCode = 'SPECIAL-SERIES' then
+        PerformCustomValidation(SeriesCode);
+
+    // Get number using new module
+    exit(NoSeries.GetNextNo(SeriesCode, WorkDate()));
+end;
+```
+
+### Complex Event Replacement
+```al
+// BEFORE (BC14-23): Multiple event subscriptions
+[EventSubscriber(ObjectType::Codeunit, Codeunit::NoSeriesManagement, 'OnAfterGetNextNo', '', true, true)]
+local procedure OnAfterGetNextNo(NoSeriesCode: Code[20]; NextNo: Code[20])
+begin
+    LogNumberAllocation(NoSeriesCode, NextNo);
+    UpdateRelatedSeries(NoSeriesCode, NextNo);
+end;
+
+// AFTER (BC24+): Integrated procedure with post-processing
+procedure AllocateNumberWithLogging(SeriesCode: Code[20]): Code[20]
+var
+    NoSeries: Codeunit "No. Series";
+    AllocatedNumber: Code[20];
+begin
+    // Allocate number
+    AllocatedNumber := NoSeries.GetNextNo(SeriesCode, WorkDate());
+
+    // Post-processing logic (replaces OnAfterGetNextNo)
+    LogNumberAllocation(SeriesCode, AllocatedNumber);
+    UpdateRelatedSeries(SeriesCode, AllocatedNumber);
+
+    exit(AllocatedNumber);
+end;
+```
+
+## Complete Migration Checklist
+
+### Step 1: Variable Declaration Updates
+```al
+// Remove these legacy declarations
+var
+    NoSeriesMgt: Codeunit NoSeriesManagement;
+
+// Replace with new module references
+var
+    NoSeries: Codeunit "No. Series";
+    NoSeriesBatch: Codeunit "No. Series - Batch";
+```
+
+### Step 2: Method Call Replacements
+```al
+// Replace all instances of these patterns:
+NoSeriesMgt.InitSeries(...) → NoSeries.GetNextNo(...)
+NoSeriesMgt.TestManual(...) → NoSeries.TestManual(...)
+NoSeriesMgt.SelectSeries(...) → NoSeries.LookupRelatedNoSeries(...)
+NoSeriesMgt.GetNextNo(..., false) → NoSeries.PeekNextNo(...)
+NoSeriesMgt.GetNextNo(..., true) → NoSeries.GetNextNo(...)
+```
+
+### Step 3: Error Handling Migration
+```al
+// BEFORE: Custom error handling required
+if not NoSeriesMgt.TryFunction(...) then
+    Error('Custom error message');
+
+// AFTER: Built-in error handling with try methods
+if not NoSeries.TryGetNextNo(ResultNo, SeriesCode, WorkDate()) then
+    HandleSpecificFailureScenario();
+```

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

@@ -0,0 +1,60 @@
+# Case Statement Performance Optimization - AL Code Samples
+
+## Frequency-Based Ordering
+
+```al
+procedure ProcessTransactionOptimized(TransactionType: Text[20]; Amount: Decimal): Boolean
+begin
+    // Order by frequency - most common first
+    case TransactionType of
+        'SALE':        // 60% of transactions
+            exit(ProcessSaleTransaction(Amount));
+        'PAYMENT':     // 25% of transactions
+            exit(ProcessPaymentTransaction(Amount));
+        'REFUND':      // 10% of transactions
+            exit(ProcessRefundTransaction(Amount));
+        else
+            exit(ProcessUnknownTransaction(TransactionType, Amount));
+    end;
+end;
+```
+
+## Enum vs Text Performance
+
+```al
+// Faster enum-based approach
+procedure ProcessTransactionEnum(TransactionType: Enum "Transaction Type"; Amount: Decimal): Boolean
+begin
+    case TransactionType of
+        TransactionType::Sale:
+            exit(ProcessSaleTransaction(Amount));
+        TransactionType::Payment:
+            exit(ProcessPaymentTransaction(Amount));
+        else
+            exit(false);
+    end;
+end;
+```
+
+## Dictionary Alternative for Large Case Sets
+
+```al
+procedure ProcessWithDictionary(ProcessingType: Text[20]; Data: Text): Text
+var
+    ProcessingFunctions: Dictionary of [Text, Integer];
+    FunctionId: Integer;
+begin
+    ProcessingFunctions.Add('FORMAT', 1);
+    ProcessingFunctions.Add('VALIDATE', 2);
+    ProcessingFunctions.Add('TRANSFORM', 3);
+    
+    if ProcessingFunctions.Get(ProcessingType, FunctionId) then
+        case FunctionId of
+            1: exit(FormatData(Data));
+            2: exit(ValidateData(Data));
+            3: exit(TransformData(Data));
+        end;
+    
+    exit('Unknown processing type');
+end;
+```

package/embedded-knowledge/domains/dean-debug/samples/compound-statements-debugging.md

@@ -0,0 +1,139 @@
+# AL Compound Statements for Enhanced Debugging Examples
+
+## Strategic Breakpoint Placement
+
+### Clear Breakpoint Locations with Compound Statements
+```al
+local procedure ProcessCustomerOrder(var SalesHeader: Record "Sales Header"): Boolean
+var
+    Customer: Record Customer;
+    ValidationResult: Boolean;
+begin
+    // Breakpoint here provides clear entry context
+    if Customer.Get(SalesHeader."Sell-to Customer No.") then begin
+        // Breakpoint here confirms customer retrieval success
+        ValidationResult := ValidateCustomerData(Customer);
+        
+        if ValidationResult then begin
+            // Breakpoint here enters successful validation path
+            if ProcessOrderValidation(SalesHeader) then begin
+                // Breakpoint here confirms order validation success
+                ProcessApprovedOrder(SalesHeader);
+                exit(true);
+            end else begin
+                // Breakpoint here enters order validation failure path
+                LogOrderValidationFailure(SalesHeader."No.");
+                exit(false);
+            end;
+        end else begin
+            // Breakpoint here enters customer validation failure path
+            LogCustomerValidationFailure(Customer."No.");
+            exit(false);
+        end;
+    end else begin
+        // Breakpoint here captures customer not found scenario
+        LogCustomerNotFound(SalesHeader."Sell-to Customer No.");
+        exit(false);
+    end;
+end;
+```
+
+## Exception Context Enhancement
+
+### Clear Exception Boundaries with Compound Statements
+```al
+local procedure ProcessDocumentPosting(var GenJournalLine: Record "Gen. Journal Line")
+var
+    PostingResult: Boolean;
+begin
+    try
+        // Compound block provides clear exception scope
+        if ValidateJournalLine(GenJournalLine) then begin
+            if CheckAccountingPeriod(GenJournalLine."Posting Date") then begin
+                PostingResult := PostJournalLine(GenJournalLine);
+                
+                if PostingResult then begin
+                    // Breakpoint here confirms successful posting
+                    LogSuccessfulPosting(GenJournalLine."Document No.");
+                end else begin
+                    // Breakpoint here captures posting failure
+                    LogPostingFailure(GenJournalLine."Document No.");
+                end;
+            end else begin
+                // Breakpoint here captures period validation failure
+                Error('Accounting period is closed for date %1', GenJournalLine."Posting Date");
+            end;
+        end else begin
+            // Breakpoint here captures journal line validation failure
+            Error('Journal line validation failed');
+        end;
+    except
+        on E: Exception do begin
+            // Breakpoint here provides clear exception context
+            LogPostingException(GenJournalLine."Document No.", E.Message);
+            
+            if E.Message.Contains('period') then begin
+                // Breakpoint here handles period-specific exceptions
+                HandlePeriodException(GenJournalLine);
+            end else begin
+                // Breakpoint here handles general posting exceptions
+                HandleGeneralPostingException(GenJournalLine, E);
+            end;
+        end;
+    end;
+end;
+```
+
+## Loop Debugging with Compound Statements
+
+### Clear Loop Iteration Boundaries
+```al
+local procedure ProcessItemBatch(var ItemBuffer: Record "Item Buffer")
+var
+    ProcessedCount: Integer;
+    ErrorCount: Integer;
+    CurrentItem: Code[20];
+begin
+    ProcessedCount := 0;
+    ErrorCount := 0;
+    
+    if ItemBuffer.FindSet() then begin
+        // Breakpoint here confirms record set found
+        repeat
+            CurrentItem := ItemBuffer."No.";
+            
+            // Breakpoint here shows current item being processed
+            if ValidateItemData(ItemBuffer) then begin
+                // Breakpoint here enters successful validation path
+                try
+                    if UpdateItemCosts(ItemBuffer) then begin
+                        // Breakpoint here confirms successful cost update
+                        ProcessedCount += 1;
+                        LogItemProcessed(CurrentItem);
+                    end else begin
+                        // Breakpoint here captures cost update failure
+                        ErrorCount += 1;
+                        LogItemError(CurrentItem, 'Cost update failed');
+                    end;
+                except
+                    on E: Exception do begin
+                        // Breakpoint here captures processing exceptions
+                        ErrorCount += 1;
+                        LogItemException(CurrentItem, E.Message);
+                    end;
+                end;
+            end else begin
+                // Breakpoint here captures validation failures
+                ErrorCount += 1;
+                LogItemValidationError(CurrentItem);
+            end;
+        until ItemBuffer.Next() = 0;
+        
+        // Breakpoint here provides final processing summary
+        LogBatchSummary(ProcessedCount, ErrorCount);
+    end else begin
+        // Breakpoint here captures empty batch scenario
+        LogEmptyBatch();
+    end;
+end;
+```