Logging und Debugging verbinden

aSeCa

Hey,

ich suche eine Möglichkeit, wie ich möglichst einfach ausgeben kann, was mein Skript grade tut. Also welche Funktion wurde aufgerufen (wenn möglich auch mit welchen Parametern), welche danach, etc...

Gibt es da eine Möglichkeit?

Ich arbeite immer mit endlos vielen ConsoleWrite und teilweise MsgBox'en, um zu verfolgen, ob Skripte das tun, was sie sollen und neben dem, dass das auch auskommentiert den Code schwerer lesbar macht, ist das recht aufwendig, das überall vorzusehen und es auch wieder auszukommentieren, wenn man den Fokus auf einen bestimmten Teil legen will.

Am Besten wäre eine einfache Möglichkeit, das auch - sogar im kompilierten Skript - ausgeben lassen zu können.

**Moombas**

Also generell kommt es viel darauf an was/wie du Programmierst. Also wie oft werden Funktionen aufgerufen etc.

Machst du bei deinen Arbeitsschritten (wo es möglich ist) Prüfungen? Wenn ja kannst du diese auch mit loggen, wenn nein warum nicht?

Generell kannst du eine Logdatei schreiben, in die du alles rein schreibst.

Du könntest z.B. einen "Debug-Modus" per Ini oder so setzen, wenn der gesetzt ist, wird geloggt, sonst nicht oder du loggst generell um bei Programmabstürzen oder -fehlern immer eine Log-Datei zur Hand zu haben.

Meine Empfehlungen:

Dauerlogging betreiben
Wenn du eine Funktion aufrufst, schreibt die Funktion als erstes z.B. "Function AB start" und als letztes "Function AB ende". Damit grenzt du einen Ausfall meistens schon mal auf eine Funktion ein.
Alles was man prüfen kann, ob es erfolgreich war oder einen Fehler gab -Prüfen! Dieses dann loggen entweder egal ob Fehler oder nicht oder nur die Fehler mit dem Fehlerwerten (alle Werte die hierzu gehören!).
Und ansonsten liegt es an dir was du mit loggst oder nicht, aber diese Stellen musst du schon selber einprogrammieren, ich wüsste aktuell keine Logik oder .au3 die sowas selber erkennt/erkennen könnte und halte das auch für unmöglich.

Zuletzt stellt sich die Frage, wie du die Log-Datei handeln willst (beim Dauerlogging):

- Nach jedem Programmstart wieder neu?

- Ein Archiv über x Log-s?

- Alles was älter ist als x-Tage löschen?

- ...

aSeCa

Hey Moombas, so habe ich mir das auch vorgestellt. Hatte nur die Hoffnung, dass man das vereinfachen kann... Ich schreibe doch recht kurze Funktionen zwecks Wiederverwendbarkeit und das verdoppelt ja fast die Zeilen des Codes (nicht ganz, aber du weißt schon).

Wenn sich da keiner mit einer Erleuchtung in Richtung Automatik meldet, werde ich das wohl mal genauso starten, wie du es vorgeschlagen hast.

**Moombas**

Wichtig dabei: Bedenke, je nachdem wie oft Funktionen aufgerufen werden etc. das deine Log-Datei immens groß werden wird!

Ein wenig eingrenzen könntest du es nur, wenn du nur an den Stellen loggst, an denen Fehler auftreten (Siehe 3.).

Dann kannst du das Error-Logging als Funktion schreiben, die du bei einem Fehler aufruft. Zu Übergebene Werte wären dann z.B.:

Funktionsname + aktueller Arbeitsschritt
dafür notwendige Parameter mit Namen
das "falsche" Ergebnis
@error (falls vorhanden)

Vorteil: Kleinere Log-Datei mit weniger (scheinbarem) Datenmüll

Nachteil: Bei einem Programmabsturz weist du nicht wo er war, da das Logging hier meist nicht mehr greifen kann.

**BugFix**

Zitat von aSeCa

Hey Moombas, so habe ich mir das auch vorgestellt. Hatte nur die Hoffnung, dass man das vereinfachen kann... Ich schreibe doch recht kurze Funktionen zwecks Wiederverwendbarkeit und das verdoppelt ja fast die Zeilen des Codes (nicht ganz, aber du weißt schon).

Wenn sich da keiner mit einer Erleuchtung in Richtung Automatik meldet, werde ich das wohl mal genauso starten, wie du es vorgeschlagen hast.

Du musst doch nur die Funktionsaufrufe in einer Funktion covern, die dann die Werte aus dem Aufruf in das Log schreibt und die Funktion startet.

Hier mal auf die Schnelle (ungetestet) für Funktionen bis 5 Parameter (kannst du beliebig erweitern, das Muster sollte klar sein).

C

; Bsp. Aufruf von z.B. "_Draw($hWnd, $x, $y)":    _Call_and_Log('_Draw', _Draw, $hWnd, $x, $y)
; LogFile liegt als Global vor ($ghLog) und ist (sinnvollerweise) als Handle zum Schreiben (Anhängen) geöffnet

Func _Call_and_Log($_sFunc, $_pFunc, $_p1=Null, $_p2=Null, $_p3=Null, $_p4=Null, $_p5=Null)
    Local $sCall
    If $_p1 = Null Then
        $sCall = $_sFunc & '( )'
        FileWrite($ghLog, $sCall & @CRLF)
        $_pFunc()
    ElseIf $_p2 = Null Then
        $sCall = $_sFunc & '( ' & $_p1 & ' )'
        FileWrite($ghLog, $sCall & @CRLF)
        $_pFunc($_p1)
    ElseIf $_p3 = Null Then
        $sCall = $_sFunc & '( ' & $_p1 & ', ' & $_p2 & ' )'
        FileWrite($ghLog, $sCall & @CRLF)
        $_pFunc($_p1, $_p2)
    ElseIf $_p4 = Null Then
        $sCall = $_sFunc & '( ' & $_p1 & ', ' & $_p2 & ', ' & $_p3 & ' )'
        FileWrite($ghLog, $sCall & @CRLF)
        $_pFunc($_p1, $_p2, $_p3)
    ElseIf $_p5 = Null Then
        $sCall = $_sFunc & '( ' & $_p1 & ', ' & $_p2 & ', ' & $_p3  & ', ' & $_p4 & ' )'
        FileWrite($ghLog, $sCall & @CRLF)
        $_pFunc($_p1, $_p2, $_p3, $_p4)
    Else
        $sCall = $_sFunc & '( ' & $_p1 & ', ' & $_p2 & ', ' & $_p3  & ', ' & $_p4   & ', ' & $_p5 & ' )'
        FileWrite($ghLog, $sCall & @CRLF)
        $_pFunc($_p1, $_p2, $_p3, $_p4, $_p5)
    EndIf
EndFunc

Alles anzeigen

**Moombas**

Dafür gibt es zig Ansatzmöglichkeiten. Ich hätte beim Aufruf des Logging die Parameter als einen String übergeben.

Deine Elseif Variante funktioniert aber nur wenn du nur EINE Funktion hast die EINEN Parameter hat, das gleiche gilt für 2,3,4,5,N-Parameter.

Hier mal mein Beispiel wie man das individuell umsetzen könnte (ungetestet!):

Code

//Aufruf:
_Call_and_Log($FunctionName, $FunctionStep, $Parameter) ; $Parameter = "ParameterName1=" & ParameterWert1 & " ParameterName2=" & ParameterWert2 usw.

//Funktion
Func _Call_and_Log($FunctionName, $FunctionStep, $Parameter)
    FileWrite($ghLog, $FunctionName &  $FunctionStep & ' start ' & @CRLF)
    FileWrite($ghLog, $FunctionName & ' - ' & $FunctionStep & ' - ' & $Parameter & @CRLF)
    Local $sPara, $check
    Select
        Case $FunctionStep = "ABC"
             $Parameter1   = stringsplit($Parameter, '=')[1]
             $Parameter2   = stringsplit($Parameter, '=')[3] ;usw.
             $sPara        = $Parameter1 & ', ' & Parameter2
        Case $FunctionStep = "BCD"
             $Parameter1   = stringsplit($Parameter, '=')[1]
             $sPara        = $Parameter1 
        Case $FunctionStep = "CDE"
             $Parameter1   = stringsplit($Parameter, '=')[1]
             $Parameter2   = stringsplit($Parameter, '=')[3]
             $Parameter3   = stringsplit($Parameter, '=')[5] ;usw.
             $sPara        = $Parameter1 & ',' & Parameter2 & ',' & Parameter3
        Case Else
             FileWrite($ghLog, $FunctionName & ' wurde nicht gefunden - ERROR' & @CRLF)   
    EndSelect
    $check = $FunctionStep($sPara)
    if $check = 1 then ;Nur wenn returncode 1 = Erfolg ist!!
        FileWrite($ghLog, $FunctionName & ' - ' & $FunctionStep & ' - OK' & @CRLF)
    else
        ;Wenn du feste Returncodes verwendest (auch für Fehler) kannst du hier diese mit einer case..select anweisung auch direkt aufschlüsseln und anstatt dem Rückgabewert (hier: $check) ausgeben
        FileWrite($ghLog, $FunctionName & ' - ' & $FunctionStep & ' - ERROR: - ' & $check & @CRLF)
    endif
    FileWrite($ghLog, $FunctionName & $FunctionStep & ' ende' & @CRLF)
EndFunc

Alles anzeigen

**water**

Im engl. Wiki findest Du eine Auflistung der verfügbaren UDFs die Dich beim Logging / Debugging unterstützen.