Performance Optimization

/wa pstart  # Start profiling
# Play normally for 1-2 minutes
/wa pstop   # Stop and display results

Load Conditions:
- Class: Death Knight
- Specialization: Blood (1)
- In Combat: Yes
- Instance Type: Party, Raid
- Player Level: >= 60

function(event, unit)
  -- Filter immediately
  if event ~= "UNIT_AURA" then return end
  if unit ~= "player" and unit ~= "target" then return end
  
  -- Now do actual checking
  local name = WA_GetUnitBuff(unit, spellID)
  return name ~= nil
end

-- BAD: Repeated API calls
function()
  for i = 1, 10 do
    local spellName = GetSpellInfo(47440) -- Called 10 times!
    -- Use spellName
  end
end

-- GOOD: Cache the result
function()
  local spellName = GetSpellInfo(47440) -- Called once
  for i = 1, 10 do
    -- Use cached spellName
  end
end

-- BEST: Cache in On Init
-- On Init:
aura_env.spellName = GetSpellInfo(47440)

-- Custom Trigger:
function()
  -- Use aura_env.spellName (no API call needed)
end

function(event, unit)
  -- Fast rejections first
  if not UnitExists("target") then
    return false  -- Exit immediately
  end
  
  if not UnitCanAttack("player", "target") then
    return false  -- Exit before expensive checks
  end
  
  -- Now do expensive operations only if needed
  local complicatedCheck = expensiveFunction()
  return complicatedCheck
end

-- On Init
aura_env.lastUpdate = 0
aura_env.throttle = 0.2 -- Update at most every 0.2 seconds

-- Custom Trigger  
function()
  local now = GetTime()
  
  -- Skip if updated recently
  if now - aura_env.lastUpdate < aura_env.throttle then
    return -- Don't update yet
  end
  
  aura_env.lastUpdate = now
  
  -- Do actual check
  local result = checkCondition()
  return result
end

-- BAD: Creates new table every call
function()
  local myTable = {} -- Memory allocation!
  for i = 1, 100 do
    myTable[i] = i
  end
  return #myTable > 50
end

-- GOOD: Reuse tables
-- On Init:
aura_env.myTable = {}

-- Custom Trigger:
function()
  local t = aura_env.myTable -- Reuse existing table
  -- ... use t
end

-- BAD: Runs every frame (100+ times per second)
Actions -> On Every Frame -> Custom
function()
  -- This is very expensive!
end

-- GOOD: Use triggers and state changes instead
-- Let triggers handle when to show/hide
-- Use On Show / On Hide for actions

-- Throttle updates
aura_env.lastFrame = aura_env.lastFrame or 0

function()
  local now = GetTime()
  if now - aura_env.lastFrame < 0.1 then -- Only every 0.1s
    return
  end
  aura_env.lastFrame = now
  
  -- Your per-frame logic
end

-- BAD: Storing large tables
aura_env.saved = aura_env.saved or {}
for i = 1, 10000 do
  aura_env.saved[i] = {data = "lots of data"}
end
-- This gets serialized and saved, causing lag!

-- GOOD: Store minimal data
aura_env.saved = aura_env.saved or {}
aura_env.saved.counter = (aura_env.saved.counter or 0) + 1
-- Small, simple data

-- On Init: Create and register
aura_env.frame = CreateFrame("Frame")
aura_env.frame:RegisterEvent("SOME_EVENT")

-- When aura is no longer needed, clean up
-- (usually not necessary, but for temporary auras)
if someCondition then
  aura_env.frame:UnregisterAllEvents()
  aura_env.frame = nil
end

Group: "Raiding Auras" (Load: In Raid)
  └─ Boss Timers
  └─ Raid Debuffs  
  └─ Cooldown Tracking

-- One dynamic group trigger that creates clones
-- instead of 10 separate auras
Trigger Type: Multi-target (creates clones)

WeakAuras Profiling Results:

1. Boss Timer Group       5.2ms  (12,450 checks)
2. Cooldown Tracker       3.1ms  (8,200 checks)
3. Raid Debuff Scanner   15.8ms  (1,240 checks) <- Problem!
4. Buff Monitor           1.2ms  (15,600 checks)

-- Enable: /wa debuglog

function(event, unit)
  -- Only log when debugging specific issues
  if aura_env.debugMode then
    DebugPrint("Event:", event, "Unit:", unit)
  end
  
  -- Your trigger logic
end

-- On Init: Setup batch update timer
aura_env.batchTimer = C_Timer.NewTicker(1.0, function()
  -- Update all related auras once per second
  WeakAuras.ScanEvents("BATCH_UPDATE")
end)

-- Multiple auras listen for "BATCH_UPDATE" event
-- All update together, once per second