feat(logging): introduce new frankenphp_log method

The CGO method allow to log a php message while binding an array of random
type as slog.Attr.

Author: burgesQ

frankenphp.c

@@ -563,6 +563,22 @@ PHP_FUNCTION(frankenphp_log_message) {
   go_log_n(message, message_len, (int)level);
 }
 
+PHP_FUNCTION(frankenphp_log) {
+  char *message = NULL;
+  size_t message_len = 0;
+  zend_long level = 0;
+  zval *context = NULL;
+
+  ZEND_PARSE_PARAMETERS_START(2, 3)
+    Z_PARAM_STRING(message, message_len)
+    Z_PARAM_LONG(level)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_ARRAY(context)
+  ZEND_PARSE_PARAMETERS_END();
+
+  go_log_attrs(message, message_len, (int)level, context);
+}
+
 PHP_MINIT_FUNCTION(frankenphp) {
   zend_function *func;
 

frankenphp.go

@@ -639,6 +639,84 @@ func go_log_n(message *C.char, len C.int, level C.int) {
 	phpLog(m, level)
 }
 
+//export go_log_attrs
+func go_log_attrs(message *C.char, len C.int, level C.int, ctx *C.zval) {
+	m := C.GoStringN(message, len)
+
+	var lvl slog.Level
+	if level < -8 || level > 8 {
+		lvl = slog.LevelInfo
+	} else {
+		lvl = slog.Level(level)
+	}
+
+	attrs, err := GoMap[any](unsafe.Pointer(ctx))
+	if err != nil {
+		attrs = nil
+	}
+
+	logger.LogAttrs(context.Background(), lvl, m, mapToAttr(attrs)...)
+}
+
+func mapToAttr(input map[string]any) []slog.Attr {
+	out := make([]slog.Attr, 0, len(input))
+
+	for key, val := range input {
+		switch v := val.(type) {
+		case string:
+			out = append(out, slog.String(key, v))
+
+		case bool:
+			out = append(out, slog.Bool(key, v))
+
+		// signed ints
+		case int:
+			out = append(out, slog.Int(key, v))
+		case int8:
+			out = append(out, slog.Int64(key, int64(v)))
+		case int16:
+			out = append(out, slog.Int64(key, int64(v)))
+		case int32:
+			out = append(out, slog.Int64(key, int64(v)))
+		case int64:
+			out = append(out, slog.Int64(key, v))
+
+		// unsigned ints
+		case uint:
+			out = append(out, slog.Uint64(key, uint64(v)))
+		case uint8:
+			out = append(out, slog.Uint64(key, uint64(v)))
+		case uint16:
+			out = append(out, slog.Uint64(key, uint64(v)))
+		case uint32:
+			out = append(out, slog.Uint64(key, uint64(v)))
+		case uint64:
+			out = append(out, slog.Uint64(key, v))
+		case uintptr:
+			out = append(out, slog.Uint64(key, uint64(v)))
+
+		// floats
+		case float32:
+			out = append(out, slog.Float64(key, float64(v)))
+		case float64:
+			out = append(out, slog.Float64(key, v))
+
+		// bonus: quelques types usuels
+		case time.Duration:
+			out = append(out, slog.Duration(key, v))
+		case time.Time:
+			out = append(out, slog.Time(key, v))
+		case error:
+			out = append(out, slog.String(key, v.Error()))
+
+		default:
+			out = append(out, slog.Any(key, val))
+		}
+	}
+
+	return out
+}
+
 func phpLog(m string, level C.int) {
 	var le syslogLevel
 	if level < C.int(syslogLevelEmerg) || level > C.int(syslogLevelDebug) {

frankenphp.stub.php

@@ -38,3 +38,9 @@ function apache_response_headers(): array|bool {}
 function mercure_publish(string|array $topics, string $data = '', bool $private = false, ?string $id = null, ?string $type = null, ?int $retry = null): string {}
 
 function frankenphp_log_message(string $message, int $level): void {}
+
+/**
+ * @param int $level The importance or severity of a log event. The higher the level, the more important or severe the event. Common levels are -4 for debug, 0 for info, 4 for warn, and 8 for error. For more details, see: https://pkg.go.dev/log/slog#Level
+ * array<string, any> $context Values of the array will be converted to the corresponding Go type (if supported by FrankenPHP) and added to the context of the structured logs using https://pkg.go.dev/log/slog#Attr
+ */
+function frankenphp_log(string $message, int $level = 0, array $context = []): void {}

frankenphp_arginfo.h

@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: dfc970945515e93e49bf676f5a08578101e62104 */
+ * Stub hash: 1dfd2ae90bb4e3a3c58669fa6e4f685ecf1f0133 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_frankenphp_handle_request, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
@@ -40,13 +40,20 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_frankenphp_log_message, 0, 2, IS
 	ZEND_ARG_TYPE_INFO(0, level, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_frankenphp_log, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, message, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, level, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, context, IS_ARRAY, 0, "[]")
+ZEND_END_ARG_INFO()
+
 ZEND_FUNCTION(frankenphp_handle_request);
 ZEND_FUNCTION(headers_send);
 ZEND_FUNCTION(frankenphp_finish_request);
 ZEND_FUNCTION(frankenphp_request_headers);
 ZEND_FUNCTION(frankenphp_response_headers);
 ZEND_FUNCTION(mercure_publish);
 ZEND_FUNCTION(frankenphp_log_message);
+ZEND_FUNCTION(frankenphp_log);
 
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(frankenphp_handle_request, arginfo_frankenphp_handle_request)
@@ -60,5 +67,6 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_RAW_FENTRY("apache_response_headers", zif_frankenphp_response_headers, arginfo_apache_response_headers, 0, NULL, NULL)
 	ZEND_FE(mercure_publish, arginfo_mercure_publish)
 	ZEND_FE(frankenphp_log_message, arginfo_frankenphp_log_message)
+	ZEND_FE(frankenphp_log, arginfo_frankenphp_log)
 	ZEND_FE_END
 };

frankenphp_test.go

@@ -1022,25 +1022,24 @@ func TestFrankenPHPLog(t *testing.T) {
 	handler := slog.NewTextHandler(&buf, &slog.HandlerOptions{Level: slog.LevelDebug})
 	logger := slog.New(handler)
 
-	runTest(t, func(handler func(http.ResponseWriter, *http.Request), _ *httptest.Server, i int) {
+	runTest(t, func(handler func(http.ResponseWriter, *http.Request), _ *httptest.Server, _ int) {
 		body, _ := testGet("http://example.com/logging.php", handler, t)
 		assert.Empty(t, body)
 	}, &testOptions{
 		logger:             logger,
 		nbParallelRequests: 1,
+		nbWorkers:          1,
 	})
 
 	logOutput := buf.String()
 
+	t.Logf("captured logs: %s", logOutput)
+
 	for level, needle := range map[string]string{
-		"emerg":  "level=ERROR msg=\"testing emerg as ERROR\" syslog_level=emerg\n",
-		"alert":  "level=ERROR msg=\"testing alert as ERROR\" syslog_level=alert\n",
-		"crit":   "level=ERROR msg=\"testing crit as ERROR\" syslog_level=crit\n",
-		"error":  "level=ERROR msg=\"testing error as ERROR\" syslog_level=err\n",
-		"warn":   "level=WARN msg=\"testing warning as WARN\" syslog_level=warning\n",
-		"notice": "level=INFO msg=\"testing notice as INFO\" syslog_level=notice\n",
-		"info":   "level=INFO msg=\"testing info as INFO\" syslog_level=info\n",
-		"debug":  "level=DEBUG msg=\"testing debug as DEBUG\" syslog_level=debug\n",
+		"debug attrs": `level=DEBUG msg="some debug message" "key int"=1`,
+		"info attrs":  `level=INFO msg="some info message" "key string"=string`,
+		"warn attrs":  `level=WARN msg="some warn message"`,
+		"error attrs": `level=ERROR msg="some error message" err="[a v]"`,
 	} {
 		assert.Containsf(t, logOutput, needle, "should contains %q log", level)
 	}

testdata/logging.php

@@ -1,10 +1,19 @@
 <?php
 
-frankenphp_log_message("testing emerg as ERROR", LOG_EMERG);
-frankenphp_log_message("testing alert as ERROR", LOG_ALERT);
-frankenphp_log_message("testing crit as ERROR", LOG_CRIT);
-frankenphp_log_message("testing error as ERROR", LOG_ERR);
-frankenphp_log_message("testing warning as WARN", LOG_WARNING);
-frankenphp_log_message("testing notice as INFO", LOG_NOTICE);
-frankenphp_log_message("testing info as INFO", LOG_INFO);
-frankenphp_log_message("testing debug as DEBUG", LOG_DEBUG);
+// TODO: test arbitrary levels.
+// TODO: test more attr type
+
+
+frankenphp_log("some debug message", -4, [
+    "key int"    => 1,
+]);
+
+frankenphp_log("some info message", 0, [
+    "key string" => "string",
+]);
+
+frankenphp_log("some warn message", 4);
+
+frankenphp_log("some error message", 8, [
+    "err" => ["a", "v"],
+]);