New INFO section for scripting engines (valkey-io#2738)

This commit adds a new `INFO` section called "Scripting Engines" that
shows the information of the current scripting engines available in the
server.

Here's an output example:

```
> info scriptingengines
# Scripting Engines
engines_count:2
engines_total_used_memory:68608
engines_total_memory_overhead:56
engine_0:name=LUA,module=built-in,abi_version=4,used_memory=68608,memory_overhead=16
engine_1:name=HELLO,module=helloengine,abi_version=4,used_memory=0,memory_overhead=40
```

---------

Signed-off-by: Ricardo Dias <ricardo.dias@percona.com>

Author: rjd15372

src/scripting_engine.c

@@ -227,6 +227,10 @@ ValkeyModule *scriptingEngineGetModule(scriptingEngine *engine) {
     return engine->module;
 }
 
+uint64_t scriptingEngineGetAbiVersion(scriptingEngine *engine) {
+    return engine->impl.methods.version;
+}
+
 /*
  * Iterates the list of engines registered in the engine manager and calls the
  * callback function with each engine.

src/scripting_engine.h

@@ -53,6 +53,7 @@ void scriptingEngineManagerForEachEngine(engineIterCallback callback, void *cont
 sds scriptingEngineGetName(scriptingEngine *engine);
 client *scriptingEngineGetClient(scriptingEngine *engine);
 ValkeyModule *scriptingEngineGetModule(scriptingEngine *engine);
+uint64_t scriptingEngineGetAbiVersion(scriptingEngine *engine);
 
 /*
  * API to call engine callback functions.

src/server.c

@@ -5736,6 +5736,62 @@ void releaseInfoSectionDict(dict *sec) {
     if (sec != cached_default_info_sections) dictRelease(sec);
 }
 
+typedef struct scriptingEngineInfoCollector {
+    sds info;
+    int total_engines;
+    size_t total_used_memory;
+    size_t total_overhead;
+} scriptingEngineInfoCollector;
+
+static void collectScriptingEngineInfo(scriptingEngine *engine, void *context) {
+    scriptingEngineInfoCollector *collector = (scriptingEngineInfoCollector *)context;
+
+    sds engine_name = scriptingEngineGetName(engine);
+    ValkeyModule *module = scriptingEngineGetModule(engine);
+    uint64_t abi_version = scriptingEngineGetAbiVersion(engine);
+
+    /* Get memory information for the engine */
+    engineMemoryInfo mem_info = scriptingEngineCallGetMemoryInfo(engine, VMSE_ALL);
+
+    collector->info = sdscatprintf(collector->info,
+                                   "engine_%d:name=%s,module=%s,abi_version=%lu,used_memory=%zu,memory_overhead=%zu\r\n",
+                                   collector->total_engines,
+                                   engine_name,
+                                   module ? module->name : "built-in",
+                                   (unsigned long)abi_version,
+                                   mem_info.used_memory,
+                                   mem_info.engine_memory_overhead);
+
+    collector->total_engines++;
+    collector->total_used_memory += mem_info.used_memory;
+    collector->total_overhead += mem_info.engine_memory_overhead;
+}
+
+sds genValkeyInfoStringScriptingEngines(sds info) {
+    scriptingEngineInfoCollector collector = {
+        .info = sdsempty(),
+        .total_engines = 0,
+        .total_used_memory = 0,
+        .total_overhead = 0};
+
+    /* Collect information from all registered engines */
+    scriptingEngineManagerForEachEngine(collectScriptingEngineInfo, &collector);
+
+    info = sdscatprintf(info,
+                        "# Scripting Engines\r\n"
+                        "engines_count:%d\r\n"
+                        "engines_total_used_memory:%zu\r\n"
+                        "engines_total_memory_overhead:%zu\r\n"
+                        "%s",
+                        collector.total_engines,
+                        collector.total_used_memory,
+                        collector.total_overhead,
+                        collector.info);
+
+    sdsfree(collector.info);
+    return info;
+}
+
 /* Create a dictionary with unique section names to be used by genValkeyInfoString.
  * 'argv' and 'argc' are list of arguments for INFO.
  * 'defaults' is an optional null terminated list of default sections.
@@ -6409,6 +6465,12 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
                             server.cluster_enabled);
     }
 
+    /* Scripting engines */
+    if (all_sections || (dictFind(section_dict, "scriptingengines") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = genValkeyInfoStringScriptingEngines(info);
+    }
+
     /* Key space */
     if (all_sections || (dictFind(section_dict, "keyspace") != NULL)) {
         if (sections++) info = sdscat(info, "\r\n");
@@ -7483,7 +7545,7 @@ int parseExtendedCommandArgumentsOrReply(client *c, int *flags, int *unit, robj
                    (opt[1] == 'f' || opt[1] == 'F') &&
                    (opt[2] == 'e' || opt[2] == 'E') &&
                    (opt[3] == 'q' || opt[3] == 'Q') && opt[4] == '\0' &&
-                   next && 
+                   next &&
                    !(*flags & ARGS_SET_NX || *flags & ARGS_SET_XX || *flags & ARGS_SET_IFEQ) && (command_type == COMMAND_SET))
         {
             *flags |= ARGS_SET_IFEQ;

tests/unit/moduleapi/scriptingengine.tcl

@@ -200,6 +200,42 @@ start_server {tags {"modules"}} {
         assert_equal [r ping] {PONG}
     }
 
+    test {Test INFO scriptingengines section} {
+        # Get the scripting engines info section
+        set info [r info scriptingengines]
+
+        # Verify the section header exists
+        assert_match "*# Scripting Engines*" $info
+
+        # Verify we have exactly 2 engines (LUA + HELLO)
+        assert_match "*engines_count:*" $info
+        regexp {engines_count:([0-9]+)} $info -> engines_count
+        assert_equal $engines_count 2
+
+        # Verify memory fields exist and are non-negative numbers
+        assert_match "*engines_total_used_memory:*" $info
+        assert_match "*engines_total_memory_overhead:*" $info
+        regexp {engines_total_used_memory:([0-9]+)} $info -> total_memory
+        regexp {engines_total_memory_overhead:([0-9]+)} $info -> total_overhead
+        assert {$total_memory >= 0}
+        assert {$total_overhead >= 0}
+
+        # Verify individual engine information exists
+        assert_match "*engine_0:*" $info
+        assert_match "*engine_1:*" $info
+
+        # Check that engines have proper format including abi_version
+        assert_match "*engine_*:name=*,module=*,abi_version=*,used_memory=*,memory_overhead=*" $info
+
+        # Verify both LUA and HELLO engines are present
+        assert_match "*name=LUA*" $info
+        assert_match "*name=HELLO*" $info
+
+        # Verify LUA is built-in and HELLO is from module
+        assert_match "*name=LUA,module=built-in*" $info
+        assert_match "*name=HELLO,module=helloengine*" $info
+    }
+
     test {Unload scripting engine module} {
         set result [r module unload helloengine]
         assert_equal $result "OK"