60ce1c9d57
Phase 15 complete (2 plans):
- 15-01: NLog 5.2.8 + nlog.config (rolling file daily/7d + console); logger fields in
FanucMachine, HeidenhainMachine, SiemensMachine, MitsubishiMachine, Lsv2Client, Program.cs;
SetState event handler catches → _log.Warn; cleanup catches annotated; ISS-003/ISS-004 closed
- 15-02: All Console.Write/WriteLine in Program.cs replaced with _log.Info (103 calls);
nlog.config console target layout=${message}, levels=Info only — Warn/Error file-only;
operator console output identical; every interaction now timestamped in log file
Milestone v0.5 Operational Quality complete.
Co-Authored-By: Claude <noreply@anthropic.com>
12 KiB
12 KiB
| phase | plan | type | wave | depends_on | files_modified | autonomous | |||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 15-logging | 01 | execute | 1 |
|
true |
Purpose
ISS-003: 18 silent catch {} blocks mean production failures are undiagnosable. ISS-004: all output goes to console only — operators cannot send a log file for support. Adding NLog with a rolling file target gives a persistent record for debugging.
Output
nlog.config— rolling file log + console, next to EXE- NLog wired into 5 production classes via
LogManager.GetCurrentClassLogger() - Event handler catch blocks changed from silent swallow to
_log.Warn - Dispose/cleanup catch blocks annotated as intentionally silent (no logging — Dispose must not rethrow)
- Program.cs error catch blocks emit
_log.Errorin addition to existingConsole.WriteLine
<acceptance_criteria>
AC-1: NLog config present and wired
Given nlog.config is placed next to NcProgramManager.exe
When the application starts
Then NLog initialises without throwing (no "NLog configuration file not found" in console)
And a logs/ subdirectory is created containing nc_program_manager.log
AC-2: Event handler exceptions reach the log
Given a StateChanged handler that throws
When SetState() fires in any machine class
Then the exception is caught and logged at WARN level (not silently swallowed)
AC-3: Dispose cleanup catch blocks are annotated
Given all Dispose() and disconnect cleanup catch blocks
When reviewed in code
Then each has a // cleanup — intentionally swallowed comment (no log call — Dispose must not rethrow)
AC-4: Program.cs errors reach the log file
Given any unhandled exception in Scarica, Invia, or arg parsing
When the catch block runs
Then _log.Error(ex, ...) is called BEFORE Console.WriteLine
And all existing Console.WriteLine calls remain unchanged
</acceptance_criteria>
Task 1: Add NLog package and nlog.config packages.config, NcProgramManager.csproj, nlog.config 1. In `packages.config`, add inside ``: ```xml ```2. In `NcProgramManager.csproj`, inside the existing `<ItemGroup>` that contains `<Reference>` entries, add:
```xml
<Reference Include="NLog, Version=5.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c, processorArchitecture=MSIL">
<HintPath>packages\NLog.5.2.8\lib\net46\NLog.dll</HintPath>
<Private>True</Private>
</Reference>
```
Also in `NcProgramManager.csproj`, inside the `<ItemGroup>` that contains `<Compile>` entries (or a new `<ItemGroup>`), add:
```xml
<Content Include="nlog.config">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</Content>
```
3. Create `nlog.config` in the project root:
```xml
<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
autoReload="true"
throwConfigExceptions="true">
<targets>
<target xsi:type="File"
name="logfile"
fileName="${basedir}/logs/nc_program_manager.log"
archiveFileName="${basedir}/logs/nc_program_manager.{#}.log"
archiveEvery="Day"
archiveNumbering="Date"
maxArchiveFiles="7"
layout="${longdate} ${level:uppercase=true:padding=5} [${logger:shortName=true}] ${message}${onexception:${newline}${exception:format=tostring}}" />
<target xsi:type="Console"
name="console"
layout="${level:uppercase=true:padding=5} [${logger:shortName=true}] ${message}" />
</targets>
<rules>
<logger name="*" minlevel="Debug" writeTo="logfile" />
<logger name="*" minlevel="Warn" writeTo="console" />
</rules>
</nlog>
```
Constraints:
- NLog package version is 5.2.8 — supports .NET 4.6+ (project is 4.7.2)
- lib/net46 is the highest .NET Framework target in the NLog 5.x package
- Console rule minlevel=Warn: logger output must NOT duplicate user-facing Console.WriteLine in Program.cs
- `throwConfigExceptions="true"` surfaces config errors at startup rather than silently failing
**A. Add using directive at top:**
```csharp
using NLog;
```
**B. Add logger field** inside the class, after existing private fields:
```csharp
private static readonly Logger _log = LogManager.GetCurrentClassLogger();
```
**C. Fix event handler catch blocks** — there is one `SetState` method in each machine class containing:
```csharp
try { h(this, next); } catch { }
```
Replace with:
```csharp
try { h(this, next); } catch (Exception ex) { _log.Warn(ex, "StateChanged handler threw"); }
```
**D. Annotate Dispose() cleanup catches** — do NOT add logging (Dispose must not rethrow):
```csharp
try { DisconnectAsync().GetAwaiter().GetResult(); } catch { /* cleanup — intentionally swallowed */ }
try { _gate.Dispose(); } catch { /* cleanup — intentionally swallowed */ }
```
**For Lsv2Client specifically (no SetState, no _gate):**
- Add `using NLog;` and `private static readonly Logger _log = LogManager.GetCurrentClassLogger();`
- In `Connect()` timeout branch: `try { _tcp.Close(); } catch { /* cleanup — intentionally swallowed */ }`
- In `Disconnect()`: annotate all 3 cleanup catches with `/* cleanup — intentionally swallowed */`
- Add connect/disconnect info logging:
```csharp
// At start of Connect(), before _tcp = new TcpClient():
_log.Info("Connecting to {0}:{1}", _config.IpAddress, _config.Port);
// After successful Login():
_log.Info("Connected to {0}", _config.IpAddress);
// At start of Disconnect():
_log.Info("Disconnecting from {0}", _config.IpAddress);
```
Constraints:
- Do NOT add logging inside `Dispose()` or disposal catch blocks — Dispose must not throw and logging adds failure risk
- Do NOT change `catch (Exception ex) { _errors.Add(...); }` blocks — already handled correctly
- Do NOT change `catch (OperationCanceledException)` blocks — correct behavior
- Logger is `static readonly` (one per class type, not per instance) — NLog standard pattern
- Do NOT add `using NLog;` if already present (check first)
2. Add logger field inside the `Program` class (or at the start of Main — static field):
```csharp
private static readonly Logger _log = LogManager.GetCurrentClassLogger();
```
3. In the arg parsing catch block (currently around line 19):
```csharp
catch (Exception e)
{
_log.Error(e, "Arg parsing failed");
Console.Write("Gestore Programmi FANUC: ");
Console.WriteLine(e.Message);
// ... rest unchanged
```
4. In the `Scarica` catch block (currently around line 157):
```csharp
catch (Exception ex)
{
_log.Error(ex, "Scarica failed");
Console.WriteLine(ex.Message);
// ... rest unchanged
```
5. In the `Invia` catch block (currently around line 253):
```csharp
catch (Exception ex)
{
_log.Error(ex, "Invia failed");
Console.WriteLine(ex.Message);
// ... rest unchanged
```
Constraints:
- `_log.Error(ex, ...)` MUST come BEFORE `Console.WriteLine(ex.Message)` — log first, then display
- ALL existing Console.WriteLine calls remain exactly as-is — do not modify or remove any
- Do NOT add logging for license failure (`Console.WriteLine("Licenza ERRATA")`) — that's a known condition, not an exception
- Do NOT add a `NLog.LogManager.Shutdown()` call — not needed for a short-lived console EXE
DO NOT CHANGE
Licensing/LicenseValidator.cs— public key constant must not be modifiedLicensing/MachineFingerprint.cs— fixed in Phase 13; not in scopeNcProgramManager.Tests/— no test changes in this phaseCnc/**/catch blocks already handling exceptions via_errors.Add(...)— correct, leave alone- All existing
Console.WriteLinecalls — supplemented only, never replaced
SCOPE LIMITS
- No logging inside Dispose() or cleanup catch paths — comment only
- No replacement of user-facing Console.WriteLine — file logging supplements via NLog
- No logging for known control-flow conditions (license failure, validation failure) — only unexpected exceptions
- No async/await changes — ISS-002 is a separate phase
- No NuGet package other than NLog — no wrapper abstraction, no DI container
<success_criteria>
- All 3 tasks completed
- All 4 ACs covered
- ISS-003 addressed: event handler swallows surfaced; cleanup swallows documented
- ISS-004 addressed: NLog file+console logging wired into all production classes
- No existing tests broken (no test files modified)
- No production behavior changed for operators (Console.WriteLine output identical) </success_criteria>