Separate shared service ownership from thread-local logging caches

tests/regressions.nim

@@ -24,12 +24,78 @@ proc `=destroy`(probe: LifetimeProbeObj) =
 proc ignoreMessage(state: LifetimeProbe, msg: LogMessage) {.gcsafe, noconv.} =
   discard
 
-proc createAndReleaseService(destroyed: ptr int) =
-  var service = initLogService()
-  service.addAppender(initCustomLogAppender(
+proc watchedService(destroyed: ptr int): LogService =
+  result = initLogService()
+  result.addAppender(initCustomLogAppender(
     LifetimeProbe(destroyed: destroyed), ignoreMessage))
+
+proc createAndReleaseService(destroyed: ptr int) =
+  var service = watchedService(destroyed)
+  service.setThreshold("worker", lvlInfo)
   # All owning handles leave scope here. No thread or cycle is involved.
 
+suite "ORC service handle lifetime":
+  test "copy, self-assignment, replacement, and move retain exactly one lifetime":
+    var firstDestroyed, replacedDestroyed = 0
+    block:
+      var first = watchedService(addr firstDestroyed)
+      var other = watchedService(addr replacedDestroyed)
+      other = first
+      check replacedDestroyed == 1
+      first = first
+      first = LogService()
+      check firstDestroyed == 0
+
+      var moved = move(other)
+      expect ValueError:
+        discard other.threadLocalRef()
+      moved.setThreshold("worker", lvlInfo)
+      let local = moved.threadLocalRef()
+      moved = LogService()
+      check firstDestroyed == 0
+      check local.getLogger("worker").isEnabled(lvlInfo)
+    check firstDestroyed == 1
+    check replacedDestroyed == 1
+
+  test "handles embedded in copied containers retain the service":
+    var destroyed = 0
+    block:
+      var source = watchedService(addr destroyed)
+      var handles = @[source, source]
+      var copied = handles
+      source = LogService()
+      handles.setLen(0)
+      check destroyed == 0
+      copied[0].setThreshold("worker", lvlWarn)
+      let local = copied[1].threadLocalRef()
+      check not local.getLogger("worker").isEnabled(lvlInfo)
+      copied.setLen(0)
+      check destroyed == 0
+    check destroyed == 1
+
+  test "an exported handle outlives the local service it came from":
+    var destroyed = 0
+    block:
+      var exported: LogService
+      block:
+        let local = watchedService(addr destroyed).threadLocalRef()
+        exported = local.service
+      check destroyed == 0
+      check exported.threadLocalRef().getLogger("worker").isEnabled(lvlInfo)
+    check destroyed == 1
+
+  test "failed local construction releases its shared owner and partial cache":
+    var destroyed = 0
+    var control: CloneControl
+    block:
+      var service = watchedService(addr destroyed)
+      service.addAppender(FallibleAppender(control: addr control))
+      control.failNext = true
+      expect ValueError:
+        discard service.threadLocalRef()
+      check destroyed == 0
+    check destroyed == 1
+
 suite "ORC ownership and configuration regressions":
   test "isEnabled observes a namespace change before any log call":
     var service = initLogService()