CawDPSMeter/CawDiagnostics.lua

-- Caw DPS Meter persistent diagnostics bootstrap (RC37)
-- Loaded first so Caw load-time Lua errors can be retained until SavedVariables are ready.
CAW_DPS_METER = CAW_DPS_METER or {}
local D = CAW_DPS_METER
D.diagVersion = "RC37-1"
D.diagMaxEntries = 400
D.diagBuffer = D.diagBuffer or {}
D.diagInHandler = false
D.diagSession = tostring({})

function D.diagStamp()
    if date then return date("%Y-%m-%d %H:%M:%S") end
    return ""
end

function D.diagNow()
    return GetTime and GetTime() or 0
end

function D.diagEnsureDB()
    CawDPSMeterErrorLog = CawDPSMeterErrorLog or {}
    -- RC34 accidentally treated the diagnostics handler's own stack frame as
    -- proof that every Lua error belonged to Caw. Drop that polluted RC34 log
    -- once on upgrade so RC35 starts with trustworthy data.
    if CawDPSMeterErrorLog.loggerVersion=="RC34-1" then
        CawDPSMeterErrorLog.entries={}
        CawDPSMeterErrorLog.total=0
        CawDPSMeterErrorLog.dropped=0
    end
    CawDPSMeterErrorLog.schema = 1
    CawDPSMeterErrorLog.loggerVersion = D.diagVersion
    CawDPSMeterErrorLog.entries = CawDPSMeterErrorLog.entries or {}
    CawDPSMeterErrorLog.total = CawDPSMeterErrorLog.total or 0
    CawDPSMeterErrorLog.dropped = CawDPSMeterErrorLog.dropped or 0
    return CawDPSMeterErrorLog
end

function D.diagInsert(rec)
    if not rec then return end
    local db = CawDPSMeterErrorLog
    if not db or not db.entries then
        table.insert(D.diagBuffer, rec)
        while table.getn(D.diagBuffer) > 80 do table.remove(D.diagBuffer,1) end
        return
    end
    local entries = db.entries
    local n = table.getn(entries)
    local last = n > 0 and entries[n] or nil
    -- Collapse identical warnings/errors that repeat rapidly (timeouts, ambiguous pets, etc.).
    if last and last.session==rec.session and last.level==rec.level and last.code==rec.code and last.message==rec.message
        and last.context==rec.context and last.stack==rec.stack
        and (rec.gameTime or 0)-(last.gameTime or 0)>=0 and (rec.gameTime or 0)-(last.gameTime or 0)<=10 then
        last.count=(last.count or 1)+1
        last.lastSeen=rec.stamp
        last.gameTime=rec.gameTime
        db.total=(db.total or 0)+1
        return
    end
    table.insert(entries,rec)
    db.total=(db.total or 0)+1
    while table.getn(entries) > (D.diagMaxEntries or 400) do
        table.remove(entries,1)
        db.dropped=(db.dropped or 0)+1
    end
end

function D.diagLog(level,code,message,context,stack)
    local rec={
        session=D.diagSession,
        stamp=D.diagStamp(), gameTime=D.diagNow(),
        level=level or "INFO", code=code or "GENERAL",
        message=tostring(message or ""), context=context,
        stack=stack, addonVersion=D.version or "load-time", count=1
    }
    D.diagInsert(rec)
end
function D.diagWarn(code,message,context) D.diagLog("WARN",code,message,context,nil) end
function D.diagCal(code,message,context) D.diagLog("CAL",code,message,context,nil) end
function D.diagError(code,message,context,stack) D.diagLog("ERROR",code,message,context,stack) end

-- Bounded summaries for on-demand target sync. Never retain packet payloads,
-- actor tables, player names or combat events, and never send extra traffic.
function D.targetSyncDiag(code,job)
    local db=D.diagEnsureDB()
    local history=db.targetSync
    if type(history)~="table" or history.schema~=1 then
        history={schema=1,sessions={}}; db.targetSync=history
    end
    local s=D.targetSyncDiagSession
    if not s then
        s={version=D.version,startedAt=D.diagStamp(),counts={},recent={}}
        D.targetSyncDiagSession=s; table.insert(history.sessions,s)
        while table.getn(history.sessions)>3 do table.remove(history.sessions,1) end
    end
    s.counts[code]=(s.counts[code] or 0)+1
    local r={code=code,stamp=D.diagStamp()}
    if job then
        r.kind=job.kind; r.segment=job.context and job.context.segment; r.channel=job.channel
        local b=job.buffer
        if b then
            r.expectedActors=b.ac; r.expectedTargets=b.tc; r.expectedRows=b.rc
            r.receivedActors=b.actorsSeen; r.receivedTargets=b.targetsSeen; r.receivedRows=b.rowsSeen
        end
    end
    s.last=code; s.updatedAt=r.stamp; table.insert(s.recent,r)
    while table.getn(s.recent)>24 do table.remove(s.recent,1) end
    s.parserEnabled=D.parserEnabled(); s.syncEnabled=D.combatSyncEnabled()
    s.input=D.dpsLogActive and "DPSLog" or (D.dpsLogProbing and "probing" or "combat-text")
end
function D.targetSyncDiagSave()
    if D.targetSyncRequest or D.targetSyncPlan or D.targetSyncOut then
        D.targetSyncDiag("RELOAD_INTERRUPTED",D.targetSyncRequest or D.targetSyncOut)
    end
    local s=D.targetSyncDiagSession
    if s then s.endedAt=D.diagStamp() end
end

function D.diagFlushBuffer()
    D.diagEnsureDB()
    local i=1
    while i<=table.getn(D.diagBuffer) do D.diagInsert(D.diagBuffer[i]); i=i+1 end
    D.diagBuffer={}
end

-- Preserve Blizzard's/current client's error presentation while passively recording Caw errors.
if geterrorhandler and seterrorhandler and not D.diagErrorHandlerInstalled then
    D.diagPreviousErrorHandler=geterrorhandler()
    D.diagErrorHandlerInstalled=true
    seterrorhandler(function(err)
        if D.diagInHandler then return end
        D.diagInHandler=true
        local msg=tostring(err or "unknown Lua error")
        local stack=nil
        if debugstack then
            local ok,s=pcall(debugstack,2,12,12)
            if ok then stack=s end
        end
        -- The handler itself necessarily appears in debugstack(). RC34 searched
        -- the whole stack for "CawDPSMeter", so CawDiagnostics.lua caused errors
        -- from unrelated addons to be recorded as ours. Ignore our handler line
        -- and inspect the actual error message / remaining stack only.
        local cleanStack=tostring(stack or "")
        cleanStack=string.gsub(cleanStack,"[^\n]*CawDiagnostics%.lua[^\n]*\n?","")
        local hay=msg.."\n"..cleanStack
        if string.find(hay,"Interface\\AddOns\\CawDPSMeter\\",1,true) or string.find(msg,"CawDPSMeter",1,true) or string.find(msg,"CawThreat",1,true) or string.find(msg,"CAW_DPS_METER",1,true) then
            D.diagError("LUA",msg,nil,stack)
        end
        local prev=D.diagPreviousErrorHandler
        if prev then pcall(prev,err) end
        D.diagInHandler=false
    end)
end



-- RC36 one-time SavedVariables housekeeping.
-- CawDPSMeterLog is still retained as a declared SavedVariable because the
-- old developer commands can intentionally populate it.  We only delete the
-- stale pre-RC36 payload once, then mark the migration complete so a freshly
-- captured developer log survives later reloads.  Empty calibration sessions
-- are safe to discard; sessions containing any captured data are preserved.
-- Keep only the most recent `max` entries of an array-style table, in order.
local function trimTail(t,max)
    if not t or not max then return t end
    local n=table.getn(t)
    if n<=max then return t end
    local kept={}
    local i
    for i=n-max+1,n do table.insert(kept,t[i]) end
    return kept
end

function D.cleanupLegacySavedVariables()
    CawDPSMeterDB=CawDPSMeterDB or {}
    local version=CawDPSMeterDB.savedVariablesCleanupVersion or 0

    if version<1 then
        local clearedLegacyLog=false
        local removedEmptyCalibration=0

        if CawDPSMeterLog~=nil then
            CawDPSMeterLog=nil
            clearedLegacyLog=true
        end

        if CawThreatCalibrationDB and CawThreatCalibrationDB.sessions then
            local kept={}
            local i=1
            while i<=table.getn(CawThreatCalibrationDB.sessions) do
                local sess=CawThreatCalibrationDB.sessions[i]
                local hasData=false
                if sess then
                    if (sess.requests or 0)>0 or (sess.responses or 0)>0 then hasData=true end
                    if sess.events and table.getn(sess.events)>0 then hasData=true end
                    if sess.casts and table.getn(sess.casts)>0 then hasData=true end
                    if sess.snapshots and table.getn(sess.snapshots)>0 then hasData=true end
                end
                if hasData then
                    table.insert(kept,sess)
                else
                    removedEmptyCalibration=removedEmptyCalibration+1
                end
                i=i+1
            end
            CawThreatCalibrationDB.sessions=kept
        end

        CawDPSMeterDB.savedVariablesCleanupVersion=1
        CawDPSMeterDB.savedVariablesCleanupAt=D.diagStamp()
        D.diagLog("INFO","SV_CLEANUP","legacy SavedVariables cleanup",
            "legacyLog="..(clearedLegacyLog and "cleared" or "none")..
            " emptyCalibrationSessions="..tostring(removedEmptyCalibration),nil)
        version=1
    end

    -- The account-wide file grew to tens of megabytes because the old
    -- per-session caps (12 sessions x 12k events/6k casts/6k snapshots/2k actor
    -- contexts) were far too generous once serialized as Lua source text. A
    -- truncated write of a file that size corrupts every SavedVariables table
    -- in the same file, including window layout. Trim any history that is
    -- already on disk down to the new, much smaller caps on next login so
    -- existing bloated accounts recover without waiting for 12 sessions to
    -- cycle out naturally.
    if version<2 then
        local sessionCap=D.threatCalMaxSessions or 3
        if CawThreatCalibrationDB and CawThreatCalibrationDB.sessions then
            local sessions=CawThreatCalibrationDB.sessions
            while table.getn(sessions)>sessionCap do table.remove(sessions,1) end
            local i
            for i=1,table.getn(sessions) do
                local s=sessions[i]
                if s then
                    s.events=trimTail(s.events,D.threatCalMaxEvents or 2000)
                    s.casts=trimTail(s.casts,D.threatCalMaxCasts or 1500)
                    s.snapshots=trimTail(s.snapshots,D.threatCalMaxSnapshots or 800)
                    s.targets=trimTail(s.targets,D.threatCalMaxTargets or 500)
                    s.requestContexts=trimTail(s.requestContexts,D.threatCalMaxRequestContexts or 500)
                    s.actorContexts=trimTail(s.actorContexts,D.threatCalMaxActorContexts or 300)
                end
            end
        end
        CawDPSMeterDB.savedVariablesCleanupVersion=2
        CawDPSMeterDB.savedVariablesCleanupAt=D.diagStamp()
        D.diagLog("INFO","SV_CLEANUP_V2","trimmed oversized calibration history to new caps",nil,nil)
    end
end

D.diagBootstrapFrame=D.diagBootstrapFrame or CreateFrame("Frame")
D.diagBootstrapFrame:RegisterEvent("ADDON_LOADED")
D.diagBootstrapFrame:RegisterEvent("PLAYER_LOGOUT")
D.diagBootstrapFrame:SetScript("OnEvent",function()
    if event=="ADDON_LOADED" and (arg1=="CawDPSMeter" or arg1==nil) then
        D.diagFlushBuffer()
        D.cleanupLegacySavedVariables()
    elseif event=="PLAYER_LOGOUT" then
        D.diagFlushBuffer()
        D.targetSyncDiagSave()
    end
end)