Generalize OTEL API and add memcache tracing support

- Rename RedisSpan -> SpanHandle for generic span handling
- Generalize TelemetryController methods: startSpan/endSpan with dbSystem param
- Rename RedisOtelSpan -> OtelSpanHandle in rbcs-server-otel
- Update Redis cache handler to use new generic API
- Add OpenTelemetry tracing for memcache GET and SET commands
- Add channel property to MemcacheRequestController for server address attribution
- Add uses TelemetryController directive in memcache module-info

Memcache spans follow the same pattern as Redis:
db.system=memcache, db.operation=GET|SET, server.address, server.port

docker/Dockerfile

@@ -1,7 +1,6 @@
 FROM eclipse-temurin:25-jre-alpine AS base-release
 RUN adduser -D rbcs
 USER rbcs
-ENV RBCS_CONFIGURATION_DIR="/etc/rbcs"
 WORKDIR /var/lib/rbcs
 
 FROM base-release AS release-vanilla
@@ -48,11 +47,9 @@ FROM scratch AS release-native
 COPY --from=base-native /etc/passwd /etc/passwd
 COPY --from=base-native /etc/rbcs /etc/rbcs
 COPY --from=base-native /var/lib/rbcs /var/lib/rbcs
-COPY --from=base-native /var/tmp/rbcs /var/tmp/rbcs
 ADD rbcs-cli.upx /usr/bin/rbcs-cli
 USER rbcs
 WORKDIR /var/lib/rbcs
-ENV RBCS_CONFIGURATION_DIR="/etc/rbcs"
 ENTRYPOINT ["/usr/bin/rbcs-cli", "-XX:MaximumHeapSizePercent=70", "-Dio.netty.tmpdir=/var/tmp/rbcs", "-Dlogback.configurationFile=/etc/rbcs/logback.xml"]
 
 FROM debian:12-slim AS release-jlink
@@ -64,5 +61,4 @@ RUN adduser -u 1000 rbcs
 USER rbcs
 WORKDIR /var/lib/rbcs
 ADD logback.xml /etc/rbcs/logback.xml
-ENV RBCS_CONFIGURATION_DIR="/etc/rbcs"
 ENTRYPOINT ["/usr/local/bin/rbcs-cli"]

gradle.properties

@@ -4,7 +4,7 @@ org.gradle.caching=true
 
 rbcs.version = 0.5.0
 
-lys.version = 2026.05.27
+lys.version = 2026.05.16
 
 gitea.maven.url = https://gitea.woggioni.net/api/packages/woggioni/maven
 docker.registry.url=gitea.woggioni.net

rbcs-api/src/main/java/net/woggioni/rbcs/api/SpanHandle.java

@@ -7,7 +7,4 @@ public interface SpanHandle {
     void setAttribute(@NotNull String key, @NotNull String value);
 
     void setAttribute(@NotNull String key, long value);
-
-    void setAttribute(@NotNull String key, boolean value);
-
 }

rbcs-api/src/main/java/net/woggioni/rbcs/api/TelemetryController.java

@@ -4,13 +4,11 @@ import io.netty.channel.ChannelHandler;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Map;
-
 public interface TelemetryController {
     void initialize();
     @NotNull ChannelHandler createHandler();
 
-    @Nullable SpanHandle startSpan(@NotNull String command);
+    @Nullable SpanHandle startSpan(@NotNull String command, @NotNull String key, @NotNull String dbSystem);
 
     void endSpan(@Nullable SpanHandle span);
 

rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/MemcacheCacheHandler.kt

@@ -262,17 +262,7 @@ class MemcacheCacheHandler(
         val key = ctx.alloc().buffer().also {
             it.writeBytes(processCacheKey(msg.key, keyPrefix, digestAlgorithm))
         }
-        val memcacheSpan = telemetryController?.startSpan("GET")?.apply {
-            setAttribute("db.system", "memcache")
-            setAttribute("db.operation.name", "GET")
-            val remoteAddr = ctx.channel().remoteAddress()
-            if (remoteAddr is InetSocketAddress) {
-                remoteAddr.hostString?.let {
-                    setAttribute("server.address", it)
-                }
-                setAttribute("server.port", remoteAddr.port.toLong())
-            }
-        }
+        val memcacheSpan = telemetryController?.startSpan("GET", msg.key, "memcache")
         val responseHandler = object : MemcacheResponseHandler {
             override fun responseReceived(response: BinaryMemcacheResponse) {
                 val status = response.status()
@@ -328,6 +318,11 @@ class MemcacheCacheHandler(
             }
         }
         client.sendRequest(key.retainedDuplicate(), responseHandler).thenAccept { requestHandle ->
+            val remoteAddr = requestHandle.channel.remoteAddress()
+            if (remoteAddr is InetSocketAddress) {
+                remoteAddr.hostString?.let { memcacheSpan?.setAttribute("server.address", it) }
+                memcacheSpan?.setAttribute("server.port", remoteAddr.port.toLong())
+            }
             log.trace(ctx) {
                 "Sending GET request for key ${msg.key} to memcache"
             }
@@ -406,18 +401,7 @@ class MemcacheCacheHandler(
                     "Received last chunk of ${msg.content().readableBytes()} bytes for memcache"
                 }
                 putRequest.write(msg.content())
-                val memcacheSpan = telemetryController?.startSpan("SET",
-                )?.apply {
-                    setAttribute("db.system", "memcache")
-                    setAttribute("db.operation.name", "SET")
-                    val remoteAddr = ctx.channel().remoteAddress()
-                    if (remoteAddr is InetSocketAddress) {
-                        remoteAddr.hostString?.let {
-                            setAttribute("server.address", it)
-                        }
-                        setAttribute("server.port", remoteAddr.port.toLong())
-                    }
-                }
+                val memcacheSpan = telemetryController?.startSpan("SET", putRequest.entryKey, "memcache")
                 putRequest.memcacheSpanRef.set(memcacheSpan)
                 val key = putRequest.digest.retainedDuplicate()
                 val (payloadSize, payloadSource) = putRequest.commit()

rbcs-server-otel/src/main/kotlin/net/woggioni/rbcs/server/otel/OtelController.kt

@@ -2,7 +2,6 @@ package net.woggioni.rbcs.server.otel
 
 import io.netty.channel.ChannelHandler
 import io.opentelemetry.api.GlobalOpenTelemetry
-import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.trace.SpanKind
 import io.opentelemetry.api.trace.StatusCode
 import io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender
@@ -45,9 +44,11 @@ class OtelController : TelemetryController {
         return NettyServerTelemetry.create(GlobalOpenTelemetry.get()).createCombinedHandler()
     }
 
-    override fun startSpan(name: String): SpanHandle {
-        val span = tracer.spanBuilder(name)
+    override fun startSpan(command: String, key: String, dbSystem: String): SpanHandle? {
+        val span = tracer.spanBuilder(command)
             .setSpanKind(SpanKind.CLIENT)
+            .setAttribute("db.system", dbSystem)
+            .setAttribute("db.operation", command)
             .startSpan()
         return OtelSpanHandle(span)
     }

rbcs-server-otel/src/main/kotlin/net/woggioni/rbcs/server/otel/OtelSpanHandle.kt

@@ -14,8 +14,4 @@ internal class OtelSpanHandle(
     override fun setAttribute(key: String, value: Long) {
         delegate.setAttribute(key, value)
     }
-
-    override fun setAttribute(key: String, value: Boolean) {
-        delegate.setAttribute(key, value)
-    }
 }

rbcs-server-redis/src/main/kotlin/net/woggioni/rbcs/server/redis/RedisCacheHandler.kt

@@ -36,6 +36,7 @@ import net.woggioni.rbcs.api.message.CacheMessage.CachePutResponse
 import net.woggioni.rbcs.api.message.CacheMessage.CacheValueFoundResponse
 import net.woggioni.rbcs.api.message.CacheMessage.CacheValueNotFoundResponse
 import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
+import net.woggioni.rbcs.api.SpanHandle
 import net.woggioni.rbcs.api.TelemetryController
 import net.woggioni.rbcs.common.ByteBufInputStream
 import net.woggioni.rbcs.common.ByteBufOutputStream
@@ -249,32 +250,21 @@ class RedisCacheHandler(
         }
         val keyBytes = processCacheKey(msg.key, keyPrefix, digestAlgorithm)
         val keyString = String(keyBytes, StandardCharsets.UTF_8)
-        val redisSpan = telemetryController?.startSpan("GET")?.apply {
-            setAttribute("db.system", "redis")
-            setAttribute("db.operation.name", "GET")
-            val remoteAddr = ctx.channel().remoteAddress()
-            if (remoteAddr is InetSocketAddress) {
-                remoteAddr.hostString?.let {
-                    setAttribute("server.address", it)
-                }
-                setAttribute("server.port", remoteAddr.port.toLong())
-            }
-        }
+        val redisSpan = telemetryController?.startSpan("GET", keyString, "redis")
         val responseHandler = object : RedisResponseHandler {
             override fun responseReceived(response: RedisMessage) {
+                try {
                     when (response) {
                         is FullBulkStringRedisMessage -> {
                             if (response === FullBulkStringRedisMessage.NULL_INSTANCE || response.content().readableBytes() == 0) {
                                 log.debug(ctx) {
                                     "Cache miss for key ${msg.key} on Redis"
                                 }
-                            telemetryController?.endSpan(redisSpan)
                                 sendMessageAndFlush(ctx, CacheValueNotFoundResponse(msg.key))
                             } else {
                                 log.debug(ctx) {
                                     "Cache hit for key ${msg.key} on Redis"
                                 }
-                            telemetryController?.endSpan(redisSpan)
                                 val getRequest = InProgressGetRequest(msg.key, ctx)
                                 inProgressRequest = getRequest
                                 getRequest.processResponse(response.content())
@@ -292,10 +282,12 @@ class RedisCacheHandler(
                             log.warn(ctx) {
                                 "Unexpected response type from Redis for key ${msg.key}: ${response.javaClass.name}"
                             }
-                        telemetryController?.endSpan(redisSpan)
                             sendMessageAndFlush(ctx, CacheValueNotFoundResponse(msg.key))
                         }
                     }
+                } finally {
+                    telemetryController?.endSpan(redisSpan)
+                }
             }
 
             override fun exceptionCaught(ex: Throwable) {
@@ -369,26 +361,16 @@ class RedisCacheHandler(
 
                 val expirySeconds = maxAge.toSeconds().toString()
 
-                val redisSpan = telemetryController?.startSpan("SET")?.apply {
-                    setAttribute("db.system", "redis")
-                    setAttribute("db.operation.name", "SET")
-                    val remoteAddr = ctx.channel().remoteAddress()
-                    if (remoteAddr is InetSocketAddress) {
-                        remoteAddr.hostString?.let {
-                            setAttribute("server.address", it)
-                        }
-                        setAttribute("server.port", remoteAddr.port.toLong())
-                    }
-                }
+                val redisSpan = telemetryController?.startSpan("SET", request.keyString, "redis")
 
                 val responseHandler = object : RedisResponseHandler {
                     override fun responseReceived(response: RedisMessage) {
+                        try {
                             when (response) {
                                 is SimpleStringRedisMessage -> {
                                     log.debug(ctx) {
                                         "Inserted key ${request.keyString} into Redis"
                                     }
-                                telemetryController?.endSpan(redisSpan)
                                     sendMessageAndFlush(ctx, CachePutResponse(request.keyString))
                                 }
 
@@ -404,6 +386,9 @@ class RedisCacheHandler(
                                     this@RedisCacheHandler.exceptionCaught(ctx, ex)
                                 }
                             }
+                        } finally {
+                            telemetryController?.endSpan(redisSpan)
+                        }
                     }
 
                     override fun exceptionCaught(ex: Throwable) {