X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafb-trace.c;h=79c7e0355a16589d6fd8f1e1894536710353db6e;hb=65353dce81a629e042800bb7b86fcd869a76727e;hp=021ab5af1bdbf57954228c50ae5c57b7a5933fc3;hpb=f26355dd547b32124ce6439ad48487cb71278c76;p=src%2Fapp-framework-binder.git

diff --git a/src/afb-trace.c b/src/afb-trace.c
index 021ab5af..79c7e035 100644
--- a/src/afb-trace.c
+++ b/src/afb-trace.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016, 2017 "IoT.bzh"
+ * Copyright (C) 2015-2020 "IoT.bzh"
  * Author José Bollo <jose.bollo@iot.bzh>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,6 +15,8 @@
  * limitations under the License.
  */
 
+#if WITH_AFB_HOOK && WITH_AFB_TRACE
+
 #define _GNU_SOURCE
 
 #include <assert.h>
@@ -27,15 +29,21 @@
 #include <pthread.h>
 
 #include <json-c/json.h>
-#define AFB_BINDING_VERSION 0
+#if !defined(JSON_C_TO_STRING_NOSLASHESCAPE)
+#define JSON_C_TO_STRING_NOSLASHESCAPE 0
+#endif
+
+#define AFB_BINDING_VERSION 3
 #include <afb/afb-binding.h>
 
 #include "afb-hook.h"
+#include "afb-hook-flags.h"
 #include "afb-cred.h"
 #include "afb-session.h"
 #include "afb-xreq.h"
 #include "afb-export.h"
 #include "afb-evt.h"
+#include "afb-session.h"
 #include "afb-trace.h"
 
 #include "wrap-json.h"
@@ -56,23 +64,16 @@
 /*****  types                                                              *****/
 /*******************************************************************************/
 
-/* structure for searching flags by names */
-struct flag
-{
-	const char *name;	/** the name */
-	int value;		/** the value */
-};
-
 /* struct for tags */
 struct tag {
 	struct tag *next;	/* link to the next */
-	char tag[1];		/* name of the tag */
+	char tag[];		/* name of the tag */
 };
 
 /* struct for events */
 struct event {
 	struct event *next;		/* link to the next event */
-	struct afb_evtid *evtid;		/* the event */
+	struct afb_evtid *evtid;	/* the event */
 };
 
 /* struct for sessions */
@@ -93,12 +94,16 @@ struct hook {
 /* types of hooks */
 enum trace_type
 {
-	Trace_Type_Xreq,	/* xreq hooks */
-	Trace_Type_Ditf,	/* export hooks */
-	Trace_Type_Svc,		/* export hooks */
-	Trace_Type_Evt,		/* evt hooks */
-	Trace_Type_Global,	/* global hooks */
-	Trace_Type_Count	/* count of types of hooks */
+	Trace_Type_Xreq,		/* xreq hooks */
+	Trace_Type_Api,			/* api hooks */
+	Trace_Type_Evt,			/* evt hooks */
+	Trace_Type_Session,		/* session hooks */
+	Trace_Type_Global,		/* global hooks */
+#if !defined(REMOVE_LEGACY_TRACE)
+	Trace_Legacy_Type_Ditf,		/* export hooks */
+	Trace_Legacy_Type_Svc,		/* export hooks */
+#endif
+	Trace_Type_Count,		/* count of types of hooks */
 };
 
 /* client data */
@@ -106,7 +111,7 @@ struct afb_trace
 {
 	int refcount;				/* reference count */
 	pthread_mutex_t mutex;			/* concurrency management */
-	struct afb_daemon *daemon;		/* daemon */
+	const char *apiname;			/* api name for events */
 	struct afb_session *bound;		/* bound to session */
 	struct event *events;			/* list of events */
 	struct tag *tags;			/* list of tags */
@@ -142,31 +147,11 @@ static void ctxt_error(char **errors, const char *format, ...)
 	}
 }
 
-/* get the value of the flag of 'name' in the array 'flags' of 'count elements */
-static int get_flag(const char *name, struct flag flags[], int count)
-{
-	/* dichotomic search */
-	int lower = 0, upper = count;
-	while (lower < upper) {
-		int mid = (lower + upper) >> 1;
-		int cmp = strcmp(name, flags[mid].name);
-		if (!cmp)
-			return flags[mid].value;
-		if (cmp < 0)
-			upper = mid;
-		else
-			lower = mid + 1;
-	}
-	return 0;
-}
-
 /* timestamp */
 static struct json_object *timestamp(const struct afb_hookid *hookid)
 {
-	char ts[50];
-
-	snprintf(ts, sizeof ts, "%llu.%06lu", (long long unsigned)hookid->time.tv_sec, (long unsigned)(hookid->time.tv_nsec / 1000));
-	return json_object_new_string(ts);
+	return json_object_new_double((double)hookid->time.tv_sec +
+			(double)hookid->time.tv_nsec * .000000001);
 }
 
 /* verbosity level name or NULL */
@@ -212,87 +197,41 @@ static void emit(void *closure, const struct afb_hookid *hookid, const char *typ
 /*****  trace the requests                                                 *****/
 /*******************************************************************************/
 
-static struct flag xreq_flags[] = { /* must be sorted by names */
-		{ "addref",		afb_hook_flag_req_addref },
-		{ "all",		afb_hook_flags_req_all },
-		{ "args",		afb_hook_flags_req_args },
-		{ "begin",		afb_hook_flag_req_begin },
-		{ "common",		afb_hook_flags_req_common },
-		{ "context",		afb_hook_flags_req_context },
-		{ "context_get",	afb_hook_flag_req_context_get },
-		{ "context_make",	afb_hook_flag_req_context_make },
-		{ "context_set",	afb_hook_flag_req_context_set },
-		{ "end",		afb_hook_flag_req_end },
-		{ "event",		afb_hook_flags_req_event },
-		{ "extra",		afb_hook_flags_req_extra },
-		{ "fail",		afb_hook_flag_req_fail },
-		{ "get",		afb_hook_flag_req_get },
-		{ "get_application_id",	afb_hook_flag_req_get_application_id },
-		{ "get_uid",		afb_hook_flag_req_get_uid },
-		{ "has_permission",	afb_hook_flag_req_has_permission },
-		{ "json",		afb_hook_flag_req_json },
-		{ "life",		afb_hook_flags_req_life },
-		{ "ref",		afb_hook_flags_req_ref },
-		{ "result",		afb_hook_flags_req_result },
-		{ "security",		afb_hook_flags_req_security },
-		{ "session",		afb_hook_flags_req_session },
-		{ "session_close",	afb_hook_flag_req_session_close },
-		{ "session_set_LOA",	afb_hook_flag_req_session_set_LOA },
-		{ "store",		afb_hook_flag_req_store },
-		{ "stores",		afb_hook_flags_req_stores },
-		{ "subcall",		afb_hook_flag_req_subcall },
-		{ "subcall_req",	afb_hook_flag_req_subcall_req },
-		{ "subcall_req_result",	afb_hook_flag_req_subcall_req_result },
-		{ "subcall_result",	afb_hook_flag_req_subcall_result },
-		{ "subcalls",		afb_hook_flags_req_subcalls },
-		{ "subcallsync",	afb_hook_flag_req_subcallsync },
-		{ "subcallsync_result",	afb_hook_flag_req_subcallsync_result },
-		{ "subscribe",		afb_hook_flag_req_subscribe },
-		{ "success",		afb_hook_flag_req_success },
-		{ "unref",		afb_hook_flag_req_unref },
-		{ "unstore",		afb_hook_flag_req_unstore },
-		{ "unsubscribe",	afb_hook_flag_req_unsubscribe },
-		{ "vverbose",		afb_hook_flag_req_vverbose },
-};
-
-/* get the xreq value for flag of 'name' */
-static int get_xreq_flag(const char *name)
-{
-	return get_flag(name, xreq_flags, (int)(sizeof xreq_flags / sizeof *xreq_flags));
-}
-
 static void hook_xreq(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *action, const char *format, ...)
 {
-	struct json_object *cred = NULL;
+	struct afb_cred *cred;
+	struct json_object *jcred = NULL;
 	const char *session = NULL;
 	va_list ap;
 
 	if (xreq->context.session)
 		session = afb_session_uuid(xreq->context.session);
 
-	if (xreq->cred)
-		wrap_json_pack(&cred, "{si ss si si ss* ss*}",
-						"uid", (int)xreq->cred->uid,
-						"user", xreq->cred->user,
-						"gid", (int)xreq->cred->gid,
-						"pid", (int)xreq->cred->pid,
-						"label", xreq->cred->label,
-						"id", xreq->cred->id
+	cred = xreq->context.credentials;
+	if (cred)
+		wrap_json_pack(&jcred, "{si ss si si ss* ss*}",
+						"uid", (int)cred->uid,
+						"user", cred->user,
+						"gid", (int)cred->gid,
+						"pid", (int)cred->pid,
+						"label", cred->label,
+						"id", cred->id
 					);
 	va_start(ap, format);
 	emit(closure, hookid, "request", "{si ss ss ss so* ss*}", format, ap,
 					"index", xreq->hookindex,
-					"api", xreq->request.api,
-					"verb", xreq->request.verb,
+					"api", xreq->request.called_api,
+					"verb", xreq->request.called_verb,
 					"action", action,
-					"credentials", cred,
+					"credentials", jcred,
 					"session", session);
 	va_end(ap);
 }
 
 static void hook_xreq_begin(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
 {
-	hook_xreq(closure, hookid, xreq, "begin", NULL);
+	hook_xreq(closure, hookid, xreq, "begin", "{sO?}",
+						"json", afb_xreq_unhooked_json((struct afb_xreq*)xreq));
 }
 
 static void hook_xreq_end(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
@@ -315,17 +254,11 @@ static void hook_xreq_get(void *closure, const struct afb_hookid *hookid, const
 						"path", arg.path);
 }
 
-static void hook_xreq_success(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *obj, const char *info)
+static void hook_xreq_reply(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *obj, const char *error, const char *info)
 {
-	hook_xreq(closure, hookid, xreq, "success", "{sO? ss?}",
+	hook_xreq(closure, hookid, xreq, "reply", "{sO? ss? ss?}",
 						"result", obj,
-						"info", info);
-}
-
-static void hook_xreq_fail(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *status, const char *info)
-{
-	hook_xreq(closure, hookid, xreq, "fail", "{ss? ss?}",
-						"status", status,
+						"error", error,
 						"info", info);
 }
 
@@ -361,21 +294,21 @@ static void hook_xreq_session_set_LOA(void *closure, const struct afb_hookid *ho
 					"result", result);
 }
 
-static void hook_xreq_subscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_eventid *eventid, int result)
+static void hook_xreq_subscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event_x2 *event, int result)
 {
 	hook_xreq(closure, hookid, xreq, "subscribe", "{s{ss si} si}",
 					"event",
-						"name", afb_evt_eventid_fullname(eventid),
-						"id", afb_evt_eventid_id(eventid),
+						"name", afb_evt_event_x2_fullname(event),
+						"id", afb_evt_event_x2_id(event),
 					"result", result);
 }
 
-static void hook_xreq_unsubscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_eventid *eventid, int result)
+static void hook_xreq_unsubscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event_x2 *event, int result)
 {
 	hook_xreq(closure, hookid, xreq, "unsubscribe", "{s{ss? si} si}",
 					"event",
-						"name", afb_evt_eventid_fullname(eventid),
-						"id", afb_evt_eventid_id(eventid),
+						"name", afb_evt_event_x2_fullname(event),
+						"id", afb_evt_event_x2_id(event),
 					"result", result);
 }
 
@@ -387,11 +320,12 @@ static void hook_xreq_subcall(void *closure, const struct afb_hookid *hookid, co
 					"args", args);
 }
 
-static void hook_xreq_subcall_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
+static void hook_xreq_subcall_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *object, const char *error, const char *info)
 {
-	hook_xreq(closure, hookid, xreq, "subcall_result", "{si sO?}",
-					"status", status,
-					"result", result);
+	hook_xreq(closure, hookid, xreq, "subcall_result", "{sO? ss? ss?}",
+					"object", object,
+					"error", error,
+					"info", info);
 }
 
 static void hook_xreq_subcallsync(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args)
@@ -402,11 +336,13 @@ static void hook_xreq_subcallsync(void *closure, const struct afb_hookid *hookid
 					"args", args);
 }
 
-static void hook_xreq_subcallsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
+static void hook_xreq_subcallsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *object, const char *error, const char *info)
 {
-	hook_xreq(closure, hookid, xreq, "subcallsync_result", "{si sO?}",
+	hook_xreq(closure, hookid, xreq, "subcallsync_result",  "{si sO? ss? ss?}",
 					"status", status,
-					"result", result);
+					"object", object,
+					"error", error,
+					"info", info);
 }
 
 static void hook_xreq_vverbose(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int level, const char *file, int line, const char *func, const char *fmt, va_list args)
@@ -445,21 +381,6 @@ static void hook_xreq_unstore(void *closure, const struct afb_hookid *hookid, co
 	hook_xreq(closure, hookid, xreq, "unstore", NULL);
 }
 
-static void hook_xreq_subcall_req(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args)
-{
-	hook_xreq(closure, hookid, xreq, "subcall_req", "{ss? ss? sO?}",
-					"api", api,
-					"verb", verb,
-					"args", args);
-}
-
-static void hook_xreq_subcall_req_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
-{
-	hook_xreq(closure, hookid, xreq, "subcall_req_result", "{si sO?}",
-					"status", status,
-					"result", result);
-}
-
 static void hook_xreq_has_permission(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *permission, int result)
 {
 	hook_xreq(closure, hookid, xreq, "has_permission", "{ss sb}",
@@ -494,15 +415,20 @@ static void hook_xreq_get_uid(void *closure, const struct afb_hookid *hookid, co
 					"result", result);
 }
 
+static void hook_xreq_get_client_info(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *result)
+{
+	hook_xreq(closure, hookid, xreq, "get_client_info", "{sO}",
+					"result", result);
+}
+
 static struct afb_hook_xreq_itf hook_xreq_itf = {
 	.hook_xreq_begin = hook_xreq_begin,
 	.hook_xreq_end = hook_xreq_end,
 	.hook_xreq_json = hook_xreq_json,
 	.hook_xreq_get = hook_xreq_get,
-	.hook_xreq_success = hook_xreq_success,
-	.hook_xreq_fail = hook_xreq_fail,
-	.hook_xreq_context_get = hook_xreq_context_get,
-	.hook_xreq_context_set = hook_xreq_context_set,
+	.hook_xreq_reply = hook_xreq_reply,
+	.hook_xreq_legacy_context_get = hook_xreq_context_get,
+	.hook_xreq_legacy_context_set = hook_xreq_context_set,
 	.hook_xreq_addref = hook_xreq_addref,
 	.hook_xreq_unref = hook_xreq_unref,
 	.hook_xreq_session_close = hook_xreq_session_close,
@@ -514,85 +440,58 @@ static struct afb_hook_xreq_itf hook_xreq_itf = {
 	.hook_xreq_subcallsync = hook_xreq_subcallsync,
 	.hook_xreq_subcallsync_result = hook_xreq_subcallsync_result,
 	.hook_xreq_vverbose = hook_xreq_vverbose,
-	.hook_xreq_store = hook_xreq_store,
-	.hook_xreq_unstore = hook_xreq_unstore,
-	.hook_xreq_subcall_req = hook_xreq_subcall_req,
-	.hook_xreq_subcall_req_result = hook_xreq_subcall_req_result,
+	.hook_xreq_legacy_store = hook_xreq_store,
+	.hook_xreq_legacy_unstore = hook_xreq_unstore,
 	.hook_xreq_has_permission = hook_xreq_has_permission,
 	.hook_xreq_get_application_id = hook_xreq_get_application_id,
 	.hook_xreq_context_make = hook_xreq_context_make,
 	.hook_xreq_get_uid = hook_xreq_get_uid,
+	.hook_xreq_get_client_info = hook_xreq_get_client_info,
 };
 
 /*******************************************************************************/
-/*****  trace the daemon interface                                         *****/
+/*****  trace the api interface                                            *****/
 /*******************************************************************************/
 
-static struct flag ditf_flags[] = { /* must be sorted by names */
-		{ "all",			afb_hook_flags_ditf_all },
-		{ "common",			afb_hook_flags_ditf_common },
-		{ "event_broadcast_after",	afb_hook_flag_ditf_event_broadcast_after },
-		{ "event_broadcast_before",	afb_hook_flag_ditf_event_broadcast_before },
-		{ "event_make",			afb_hook_flag_ditf_event_make },
-		{ "extra",			afb_hook_flags_ditf_extra },
-		{ "get_event_loop",		afb_hook_flag_ditf_get_event_loop },
-		{ "get_system_bus",		afb_hook_flag_ditf_get_system_bus },
-		{ "get_user_bus",		afb_hook_flag_ditf_get_user_bus },
-		{ "queue_job",			afb_hook_flag_ditf_queue_job },
-		{ "require_api",		afb_hook_flag_ditf_require_api },
-		{ "require_api_result",		afb_hook_flag_ditf_require_api_result },
-		{ "rootdir_get_fd",		afb_hook_flag_ditf_rootdir_get_fd },
-		{ "rootdir_open_locale",	afb_hook_flag_ditf_rootdir_open_locale },
-		{ "unstore_req",		afb_hook_flag_ditf_unstore_req },
-		{ "vverbose",			afb_hook_flag_ditf_vverbose },
-};
-
-/* get the export value for flag of 'name' */
-static int get_ditf_flag(const char *name)
-{
-	return get_flag(name, ditf_flags, (int)(sizeof ditf_flags / sizeof *ditf_flags));
-}
-
-
-static void hook_ditf(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
+static void hook_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
 {
 	va_list ap;
 
 	va_start(ap, format);
-	emit(closure, hookid, "daemon", "{ss ss}", format, ap,
+	emit(closure, hookid, "api", "{ss ss}", format, ap,
 					"api", afb_export_apiname(export),
 					"action", action);
 	va_end(ap);
 }
 
-static void hook_ditf_event_broadcast_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object)
+static void hook_api_event_broadcast_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object)
 {
-	hook_ditf(closure, hookid, export, "event_broadcast_before", "{ss sO*}",
+	hook_api(closure, hookid, export, "event_broadcast_before", "{ss sO?}",
 			"name", name, "data", object);
 }
 
-static void hook_ditf_event_broadcast_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object, int result)
+static void hook_api_event_broadcast_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object, int result)
 {
-	hook_ditf(closure, hookid, export, "event_broadcast_after", "{ss sO* si}",
+	hook_api(closure, hookid, export, "event_broadcast_after", "{ss sO? si}",
 			"name", name, "data", object, "result", result);
 }
 
-static void hook_ditf_get_event_loop(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_event *result)
+static void hook_api_get_event_loop(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_event *result)
 {
-	hook_ditf(closure, hookid, export, "get_event_loop", NULL);
+	hook_api(closure, hookid, export, "get_event_loop", NULL);
 }
 
-static void hook_ditf_get_user_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
+static void hook_api_get_user_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
 {
-	hook_ditf(closure, hookid, export, "get_user_bus", NULL);
+	hook_api(closure, hookid, export, "get_user_bus", NULL);
 }
 
-static void hook_ditf_get_system_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
+static void hook_api_get_system_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
 {
-	hook_ditf(closure, hookid, export, "get_system_bus", NULL);
+	hook_api(closure, hookid, export, "get_system_bus", NULL);
 }
 
-static void hook_ditf_vverbose(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int level, const char *file, int line, const char *function, const char *fmt, va_list args)
+static void hook_api_vverbose(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int level, const char *file, int line, const char *function, const char *fmt, va_list args)
 {
 	struct json_object *pos;
 	int len;
@@ -609,7 +508,7 @@ static void hook_ditf_vverbose(void *closure, const struct afb_hookid *hookid, c
 	if (file)
 		wrap_json_pack(&pos, "{ss si ss*}", "file", file, "line", line, "function", function);
 
-	hook_ditf(closure, hookid, export, "vverbose", "{si ss* ss? so*}",
+	hook_api(closure, hookid, export, "vverbose", "{si ss* ss? so*}",
 					"level", level,
  					"type", verbosity_level_name(level),
 					len < 0 ? "format" : "message", len < 0 ? fmt : msg,
@@ -618,193 +517,263 @@ static void hook_ditf_vverbose(void *closure, const struct afb_hookid *hookid, c
 	free(msg);
 }
 
-static void hook_ditf_event_make(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct afb_eventid *result)
+static void hook_api_event_make(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct afb_event_x2 *result)
 {
-	hook_ditf(closure, hookid, export, "event_make", "{ss ss si}",
-			"name", name, "event", afb_evt_eventid_fullname(result), "id", afb_evt_eventid_id(result));
+	hook_api(closure, hookid, export, "event_make", "{ss ss si}",
+			"name", name, "event", afb_evt_event_x2_fullname(result), "id", afb_evt_event_x2_id(result));
 }
 
-static void hook_ditf_rootdir_get_fd(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+static void hook_api_rootdir_get_fd(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
 {
-	char path[PATH_MAX];
+	char path[PATH_MAX], proc[100];
+	const char *key, *val;
+	ssize_t s;
 
 	if (result >= 0) {
-		sprintf(path, "/proc/self/fd/%d", result);
-		readlink(path, path, sizeof path);
+		snprintf(proc, sizeof proc, "/proc/self/fd/%d", result);
+		s = readlink(proc, path, sizeof path);
+		path[s < 0 ? 0 : s >= sizeof path ? sizeof path - 1 : s] = 0;
+		key = "path";
+		val = path;
+	} else {
+		key = "error";
+		val = strerror(errno);
 	}
 
-	hook_ditf(closure, hookid, export, "rootdir_get_fd", "{ss}",
-			result < 0 ? "path" : "error",
-			result < 0 ? strerror(errno) : path);
+	hook_api(closure, hookid, export, "rootdir_get_fd", "{ss}", key, val);
 }
 
-static void hook_ditf_rootdir_open_locale(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *filename, int flags, const char *locale, int result)
+static void hook_api_rootdir_open_locale(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *filename, int flags, const char *locale, int result)
 {
-	char path[PATH_MAX];
+	char path[PATH_MAX], proc[100];
+	const char *key, *val;
+	ssize_t s;
 
 	if (result >= 0) {
-		sprintf(path, "/proc/self/fd/%d", result);
-		readlink(path, path, sizeof path);
+		snprintf(proc, sizeof proc, "/proc/self/fd/%d", result);
+		s = readlink(proc, path, sizeof path);
+		path[s < 0 ? 0 : s >= sizeof path ? sizeof path - 1 : s] = 0;
+		key = "path";
+		val = path;
+	} else {
+		key = "error";
+		val = strerror(errno);
 	}
 
-	hook_ditf(closure, hookid, export, "rootdir_open_locale", "{ss si ss* ss}",
+	hook_api(closure, hookid, export, "rootdir_open_locale", "{ss si ss* ss}",
 			"file", filename,
 			"flags", flags,
 			"locale", locale,
-			result < 0 ? "path" : "error",
-			result < 0 ? strerror(errno) : path);
+			key, val);
 }
 
-static void hook_ditf_queue_job(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout, int result)
+static void hook_api_queue_job(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout, int result)
 {
-	hook_ditf(closure, hookid, export, "queue_job", "{ss}", "result", result);
+	hook_api(closure, hookid, export, "queue_job", "{ss}", "result", result);
 }
 
-static void hook_ditf_unstore_req(void * closure, const struct afb_hookid *hookid, const struct afb_export *export, struct afb_stored_req *sreq)
+static void hook_api_unstore_req(void * closure, const struct afb_hookid *hookid, const struct afb_export *export, struct afb_stored_req *sreq)
 {
-	hook_ditf(closure, hookid, export, "unstore_req", NULL);
+	hook_api(closure, hookid, export, "unstore_req", NULL);
 }
 
-static void hook_ditf_require_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized)
+static void hook_api_require_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized)
 {
-	hook_ditf(closure, hookid, export, "require_api", "{ss sb}", "name", name, "initialized", initialized);
+	hook_api(closure, hookid, export, "require_api", "{ss sb}", "name", name, "initialized", initialized);
 }
 
-static void hook_ditf_require_api_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized, int result)
+static void hook_api_require_api_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized, int result)
 {
-	hook_ditf(closure, hookid, export, "require_api_result", "{ss sb si}", "name", name, "initialized", initialized, "result", result);
+	hook_api(closure, hookid, export, "require_api_result", "{ss sb si}", "name", name, "initialized", initialized, "result", result);
 }
 
-static struct afb_hook_ditf_itf hook_ditf_itf = {
-	.hook_ditf_event_broadcast_before = hook_ditf_event_broadcast_before,
-	.hook_ditf_event_broadcast_after = hook_ditf_event_broadcast_after,
-	.hook_ditf_get_event_loop = hook_ditf_get_event_loop,
-	.hook_ditf_get_user_bus = hook_ditf_get_user_bus,
-	.hook_ditf_get_system_bus = hook_ditf_get_system_bus,
-	.hook_ditf_vverbose = hook_ditf_vverbose,
-	.hook_ditf_event_make = hook_ditf_event_make,
-	.hook_ditf_rootdir_get_fd = hook_ditf_rootdir_get_fd,
-	.hook_ditf_rootdir_open_locale = hook_ditf_rootdir_open_locale,
-	.hook_ditf_queue_job = hook_ditf_queue_job,
-	.hook_ditf_unstore_req = hook_ditf_unstore_req,
-	.hook_ditf_require_api = hook_ditf_require_api,
-	.hook_ditf_require_api_result = hook_ditf_require_api_result
-};
+static void hook_api_add_alias_cb(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *alias, int result)
+{
+	hook_api(closure, hookid, export, "add_alias", "{si ss? ss}", "status", result, "api", api, "alias", alias);
+}
 
-/*******************************************************************************/
-/*****  trace the services                                                 *****/
-/*******************************************************************************/
+static void hook_api_start_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export)
+{
+	hook_api(closure, hookid, export, "start_before", NULL);
+}
 
-static struct flag svc_flags[] = { /* must be sorted by names */
-		{ "all",		afb_hook_flags_svc_all },
-		{ "call",		afb_hook_flag_svc_call },
-		{ "call_result",	afb_hook_flag_svc_call_result },
-		{ "callsync",		afb_hook_flag_svc_callsync },
-		{ "callsync_result",	afb_hook_flag_svc_callsync_result },
-		{ "on_event_after",	afb_hook_flag_svc_on_event_after },
-		{ "on_event_before",	afb_hook_flag_svc_on_event_before },
-		{ "start_after",	afb_hook_flag_svc_start_after },
-		{ "start_before",	afb_hook_flag_svc_start_before },
-};
+static void hook_api_start_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status)
+{
+	hook_api(closure, hookid, export, "start_after", "{si}", "result", status);
+}
 
-/* get the export value for flag of 'name' */
-static int get_svc_flag(const char *name)
+static void hook_api_on_event_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
 {
-	return get_flag(name, svc_flags, (int)(sizeof svc_flags / sizeof *svc_flags));
+	hook_api(closure, hookid, export, "on_event_before", "{ss si sO*}",
+			"event", event, "id", evtid, "data", object);
 }
 
-static void hook_svc(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
+static void hook_api_on_event_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
 {
-	va_list ap;
+	hook_api(closure, hookid, export, "on_event_after", "{ss si sO?}",
+			"event", event, "id", evtid, "data", object);
+}
 
-	va_start(ap, format);
-	emit(closure, hookid, "service", "{ss ss}", format, ap,
-					"api", afb_export_apiname(export),
-					"action", action);
-	va_end(ap);
+static void hook_api_call(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
+{
+	hook_api(closure, hookid, export, "call", "{ss ss sO?}",
+			"api", api, "verb", verb, "args", args);
 }
 
-static void hook_svc_start_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export)
+static void hook_api_call_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct json_object *object, const char *error, const char *info)
 {
-	hook_svc(closure, hookid, export, "start_before", NULL);
+	hook_api(closure, hookid, export, "call_result", "{sO? ss? ss?}",
+			"object", object, "error", error, "info", info);
 }
 
-static void hook_svc_start_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status)
+static void hook_api_callsync(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
 {
-	hook_svc(closure, hookid, export, "start_after", "{si}", "result", status);
+	hook_api(closure, hookid, export, "callsync", "{ss ss sO?}",
+			"api", api, "verb", verb, "args", args);
 }
 
-static void hook_svc_on_event_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
+static void hook_api_callsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *object, const char *error, const char *info)
 {
-	hook_svc(closure, hookid, export, "on_event_before", "{ss si sO*}",
-			"event", event, "id", evtid, "data", object);
+	hook_api(closure, hookid, export, "callsync_result", "{si sO? ss? ss?}",
+			"status", status, "object", object, "error", error, "info", info);
 }
 
-static void hook_svc_on_event_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
+static void hook_api_new_api_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *info, int noconcurrency)
 {
-	hook_svc(closure, hookid, export, "on_event_after", "{ss si sO*}",
-			"event", event, "id", evtid, "data", object);
+	hook_api(closure, hookid, export, "new_api.before", "{ss ss? sb}",
+			"api", api, "info", info, "noconcurrency", noconcurrency);
 }
 
-static void hook_svc_call(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
+static void hook_api_new_api_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *api)
 {
-	hook_svc(closure, hookid, export, "call", "{ss ss sO*}",
-			"api", api, "verb", verb, "args", args);
+	hook_api(closure, hookid, export, "new_api.after", "{si ss}",
+						"status", result, "api", api);
 }
 
-static void hook_svc_call_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *result)
+static void hook_api_api_set_verbs_v2(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const struct afb_verb_v2 *verbs)
 {
-	hook_svc(closure, hookid, export, "call_result", "{si sO*}",
-			"status", status, "result", result);
+	hook_api(closure, hookid, export, "set_verbs_v2", "{si}",  "status", result);
 }
 
-static void hook_svc_callsync(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
+static void hook_api_api_set_verbs_v3(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const struct afb_verb_v3 *verbs)
 {
-	hook_svc(closure, hookid, export, "callsync", "{ss ss sO*}",
-			"api", api, "verb", verb, "args", args);
+	hook_api(closure, hookid, export, "set_verbs_v3", "{si}",  "status", result);
 }
 
-static void hook_svc_callsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *result)
+
+static void hook_api_api_add_verb(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *verb, const char *info, int glob)
 {
-	hook_svc(closure, hookid, export, "callsync_result", "{si sO*}",
-			"status", status, "result", result);
+	hook_api(closure, hookid, export, "add_verb", "{si ss ss? sb}", "status", result, "verb", verb, "info", info, "glob", glob);
 }
 
-static struct afb_hook_svc_itf hook_svc_itf = {
-	.hook_svc_start_before = hook_svc_start_before,
-	.hook_svc_start_after = hook_svc_start_after,
-	.hook_svc_on_event_before = hook_svc_on_event_before,
-	.hook_svc_on_event_after = hook_svc_on_event_after,
-	.hook_svc_call = hook_svc_call,
-	.hook_svc_call_result = hook_svc_call_result,
-	.hook_svc_callsync = hook_svc_callsync,
-	.hook_svc_callsync_result = hook_svc_callsync_result
-};
+static void hook_api_api_del_verb(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *verb)
+{
+	hook_api(closure, hookid, export, "del_verb", "{si ss}", "status", result, "verb", verb);
+}
 
-/*******************************************************************************/
-/*****  trace the events                                                   *****/
-/*******************************************************************************/
+static void hook_api_api_set_on_event(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+{
+	hook_api(closure, hookid, export, "set_on_event", "{si}",  "status", result);
+}
 
-static struct flag evt_flags[] = { /* must be sorted by names */
-		{ "addref",		afb_hook_flag_evt_addref },
-		{ "all",		afb_hook_flags_evt_all },
-		{ "broadcast_after",	afb_hook_flag_evt_broadcast_after },
-		{ "broadcast_before",	afb_hook_flag_evt_broadcast_before },
-		{ "common",		afb_hook_flags_evt_common },
-		{ "create",		afb_hook_flag_evt_create },
-		{ "extra",		afb_hook_flags_evt_extra },
-		{ "name",		afb_hook_flag_evt_name },
-		{ "push_after",		afb_hook_flag_evt_push_after },
-		{ "push_before",	afb_hook_flag_evt_push_before },
-		{ "unref",		afb_hook_flag_evt_unref },
-};
+static void hook_api_api_set_on_init(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+{
+	hook_api(closure, hookid, export, "set_on_init", "{si}",  "status", result);
+}
+
+static void hook_api_api_seal(void *closure, const struct afb_hookid *hookid, const struct afb_export *export)
+{
+	hook_api(closure, hookid, export, "seal", NULL);
+}
 
-/* get the evt value for flag of 'name' */
-static int get_evt_flag(const char *name)
+static void hook_api_event_handler_add(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *pattern)
 {
-	return get_flag(name, evt_flags, (int)(sizeof evt_flags / sizeof *evt_flags));
+	hook_api(closure, hookid, export, "event_handler_add", "{si ss?}",  "status", result, "pattern", pattern);
 }
 
+static void hook_api_event_handler_del(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *pattern)
+{
+	hook_api(closure, hookid, export, "event_handler_del", "{si ss?}",  "status", result, "pattern", pattern);
+}
+
+static void hook_api_class_provide(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *name)
+{
+	hook_api(closure, hookid, export, "class_provide", "{si ss?}",  "status", result, "name", name);
+}
+
+static void hook_api_class_require(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *name)
+{
+	hook_api(closure, hookid, export, "class_require", "{si ss?}",  "status", result, "name", name);
+}
+
+static void hook_api_delete_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+{
+	hook_api(closure, hookid, export, "delete_api", "{si}",  "status", result);
+}
+
+static void hook_api_on_event_handler_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int event_x2, struct json_object *object, const char *pattern)
+{
+	hook_api(closure, hookid, export, "on_event_handler.before",
+		"{ss ss sO?}", "pattern", pattern, "event", event, "data", object);
+}
+
+static void hook_api_on_event_handler_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int event_x2, struct json_object *object, const char *pattern)
+{
+	hook_api(closure, hookid, export, "on_event_handler.after",
+		"{ss ss sO?}", "pattern", pattern, "event", event, "data", object);
+}
+
+static void hook_api_settings(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct json_object *object)
+{
+	hook_api(closure, hookid, export, "settings", "{sO}", "settings", object);
+}
+
+static struct afb_hook_api_itf hook_api_itf = {
+	.hook_api_event_broadcast_before = hook_api_event_broadcast_before,
+	.hook_api_event_broadcast_after = hook_api_event_broadcast_after,
+	.hook_api_get_event_loop = hook_api_get_event_loop,
+	.hook_api_get_user_bus = hook_api_get_user_bus,
+	.hook_api_get_system_bus = hook_api_get_system_bus,
+	.hook_api_vverbose = hook_api_vverbose,
+	.hook_api_event_make = hook_api_event_make,
+	.hook_api_rootdir_get_fd = hook_api_rootdir_get_fd,
+	.hook_api_rootdir_open_locale = hook_api_rootdir_open_locale,
+	.hook_api_queue_job = hook_api_queue_job,
+	.hook_api_legacy_unstore_req = hook_api_unstore_req,
+	.hook_api_require_api = hook_api_require_api,
+	.hook_api_require_api_result = hook_api_require_api_result,
+	.hook_api_add_alias = hook_api_add_alias_cb,
+	.hook_api_start_before = hook_api_start_before,
+	.hook_api_start_after = hook_api_start_after,
+	.hook_api_on_event_before = hook_api_on_event_before,
+	.hook_api_on_event_after = hook_api_on_event_after,
+	.hook_api_call = hook_api_call,
+	.hook_api_call_result = hook_api_call_result,
+	.hook_api_callsync = hook_api_callsync,
+	.hook_api_callsync_result = hook_api_callsync_result,
+	.hook_api_new_api_before = hook_api_new_api_before,
+	.hook_api_new_api_after = hook_api_new_api_after,
+	.hook_api_api_set_verbs_v2 = hook_api_api_set_verbs_v2,
+	.hook_api_api_set_verbs_v3 = hook_api_api_set_verbs_v3,
+	.hook_api_api_add_verb = hook_api_api_add_verb,
+	.hook_api_api_del_verb = hook_api_api_del_verb,
+	.hook_api_api_set_on_event = hook_api_api_set_on_event,
+	.hook_api_api_set_on_init = hook_api_api_set_on_init,
+	.hook_api_api_seal = hook_api_api_seal,
+	.hook_api_event_handler_add = hook_api_event_handler_add,
+	.hook_api_event_handler_del = hook_api_event_handler_del,
+	.hook_api_class_provide = hook_api_class_provide,
+	.hook_api_class_require = hook_api_class_require,
+	.hook_api_delete_api = hook_api_delete_api,
+	.hook_api_on_event_handler_before = hook_api_on_event_handler_before,
+	.hook_api_on_event_handler_after = hook_api_on_event_handler_after,
+	.hook_api_settings = hook_api_settings,
+};
+
+/*******************************************************************************/
+/*****  trace the events                                                   *****/
+/*******************************************************************************/
+
 static void hook_evt(void *closure, const struct afb_hookid *hookid, const char *evt, int id, const char *action, const char *format, ...)
 {
 	va_list ap;
@@ -870,20 +839,57 @@ static struct afb_hook_evt_itf hook_evt_itf = {
 };
 
 /*******************************************************************************/
-/*****  trace the globals                                                  *****/
+/*****  trace the sessions                                                 *****/
 /*******************************************************************************/
 
-static struct flag global_flags[] = { /* must be sorted by names */
-		{ "all",		afb_hook_flags_global_all },
-		{ "vverbose",		afb_hook_flag_global_vverbose },
-};
+static void hook_session(void *closure, const struct afb_hookid *hookid, struct afb_session *session, const char *action, const char *format, ...)
+{
+	va_list ap;
+
+	va_start(ap, format);
+	emit(closure, hookid, "session", "{ss ss}", format, ap,
+					"uuid", afb_session_uuid(session),
+					"action", action);
+	va_end(ap);
+}
+
+static void hook_session_create(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+	hook_session(closure, hookid, session, "create", NULL);
+}
 
-/* get the global value for flag of 'name' */
-static int get_global_flag(const char *name)
+static void hook_session_close(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 {
-	return get_flag(name, global_flags, (int)(sizeof global_flags / sizeof *global_flags));
+	hook_session(closure, hookid, session, "close", NULL);
 }
 
+static void hook_session_destroy(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+	hook_session(closure, hookid, session, "destroy", NULL);
+}
+
+static void hook_session_addref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+	hook_session(closure, hookid, session, "addref", NULL);
+}
+
+static void hook_session_unref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+	hook_session(closure, hookid, session, "unref", NULL);
+}
+
+static struct afb_hook_session_itf hook_session_itf = {
+	.hook_session_create = hook_session_create,
+	.hook_session_close = hook_session_close,
+	.hook_session_destroy = hook_session_destroy,
+	.hook_session_addref = hook_session_addref,
+	.hook_session_unref = hook_session_unref
+};
+
+/*******************************************************************************/
+/*****  trace the globals                                                  *****/
+/*******************************************************************************/
+
 static void hook_global(void *closure, const struct afb_hookid *hookid, const char *action, const char *format, ...)
 {
 	va_list ap;
@@ -940,32 +946,46 @@ abstracting[Trace_Type_Count] =
 	{
 		.name = "request",
 		.unref =  (void(*)(void*))afb_hook_unref_xreq,
-		.get_flag = get_xreq_flag
-	},
-	[Trace_Type_Ditf] =
-	{
-		.name = "daemon",
-		.unref =  (void(*)(void*))afb_hook_unref_ditf,
-		.get_flag = get_ditf_flag
+		.get_flag = afb_hook_flags_xreq_from_text
 	},
-	[Trace_Type_Svc] =
+	[Trace_Type_Api] =
 	{
-		.name = "service",
-		.unref =  (void(*)(void*))afb_hook_unref_svc,
-		.get_flag = get_svc_flag
+		.name = "api",
+		.unref =  (void(*)(void*))afb_hook_unref_api,
+		.get_flag = afb_hook_flags_api_from_text
 	},
 	[Trace_Type_Evt] =
 	{
 		.name = "event",
 		.unref =  (void(*)(void*))afb_hook_unref_evt,
-		.get_flag = get_evt_flag
+		.get_flag = afb_hook_flags_evt_from_text
+	},
+	[Trace_Type_Session] =
+	{
+		.name = "session",
+		.unref =  (void(*)(void*))afb_hook_unref_session,
+		.get_flag = afb_hook_flags_session_from_text
 	},
 	[Trace_Type_Global] =
 	{
 		.name = "global",
 		.unref =  (void(*)(void*))afb_hook_unref_global,
-		.get_flag = get_global_flag
+		.get_flag = afb_hook_flags_global_from_text
+	},
+#if !defined(REMOVE_LEGACY_TRACE)
+	[Trace_Legacy_Type_Ditf] =
+	{
+		.name = "daemon",
+		.unref =  (void(*)(void*))afb_hook_unref_api,
+		.get_flag = afb_hook_flags_legacy_ditf_from_text
+	},
+	[Trace_Legacy_Type_Svc] =
+	{
+		.name = "service",
+		.unref =  (void(*)(void*))afb_hook_unref_api,
+		.get_flag = afb_hook_flags_legacy_svc_from_text
 	},
+#endif
 };
 
 /*******************************************************************************/
@@ -1049,7 +1069,7 @@ static struct tag *trace_get_tag(struct afb_trace *trace, const char *name, int
 
 	if (!tag && alloc) {
 		/* creation if needed */
-		tag = malloc(sizeof * tag + strlen(name));
+		tag = malloc(sizeof * tag + 1 + strlen(name));
 		if (tag) {
 			strcpy(tag->tag, name);
 			tag->next = trace->tags;
@@ -1065,7 +1085,6 @@ static struct tag *trace_get_tag(struct afb_trace *trace, const char *name, int
  */
 static struct event *trace_get_event(struct afb_trace *trace, const char *name, int alloc)
 {
-	struct afb_event e;
 	struct event *event;
 
 	/* search the event */
@@ -1076,8 +1095,7 @@ static struct event *trace_get_event(struct afb_trace *trace, const char *name,
 	if (!event && alloc) {
 		event = malloc(sizeof * event);
 		if (event) {
-			e = afb_daemon_make_event_v1(*trace->daemon, name);
-			event->evtid = afb_evt_eventid_to_evtid(afb_event_to_eventid(e));
+			event->evtid = afb_evt_evtid_create2(trace->apiname, name);
 			if (event->evtid) {
 				event->next = trace->events;
 				trace->events = event;
@@ -1164,7 +1182,7 @@ static void trace_attach_hook(struct afb_trace *trace, struct hook *hook, enum t
 struct context
 {
 	struct afb_trace *trace;
-	struct afb_req req;
+	afb_req_t req;
 	char *errors;
 };
 
@@ -1173,14 +1191,13 @@ struct desc
 	struct context *context;
 	const char *name;
 	const char *tag;
-	const char *session;
-	const char *api;
-	const char *verb;
+	const char *uuid;
+	const char *apiname;
+	const char *verbname;
 	const char *pattern;
 	int flags[Trace_Type_Count];
 };
 
-
 static void addhook(struct desc *desc, enum trace_type type)
 {
 	struct hook *hook;
@@ -1195,7 +1212,7 @@ static void addhook(struct desc *desc, enum trace_type type)
 			ctxt_error(&desc->context->errors, "tracing %s is forbidden", abstracting[type].name);
 			return;
 		}
-		if (desc->session) {
+		if (desc->uuid) {
 			ctxt_error(&desc->context->errors, "setting session is forbidden");
 			return;
 		}
@@ -1211,29 +1228,29 @@ static void addhook(struct desc *desc, enum trace_type type)
 	/* create the hook handler */
 	switch (type) {
 	case Trace_Type_Xreq:
-		if (!desc->session)
+		if (!desc->uuid)
 			session = afb_session_addref(bind);
 		else {
-			session = trace_get_session_by_uuid(trace, desc->session, 1);
+			session = trace_get_session_by_uuid(trace, desc->uuid, 1);
 			if (!session) {
 				ctxt_error(&desc->context->errors, "allocation of session failed");
 				free(hook);
 				return;
 			}
 		}
-		hook->handler = afb_hook_create_xreq(desc->api, desc->verb, session,
+		hook->handler = afb_hook_create_xreq(desc->apiname, desc->verbname, session,
 				desc->flags[type], &hook_xreq_itf, hook);
 		afb_session_unref(session);
 		break;
-	case Trace_Type_Ditf:
-		hook->handler = afb_hook_create_ditf(desc->api, desc->flags[type], &hook_ditf_itf, hook);
-		break;
-	case Trace_Type_Svc:
-		hook->handler = afb_hook_create_svc(desc->api, desc->flags[type], &hook_svc_itf, hook);
+	case Trace_Type_Api:
+		hook->handler = afb_hook_create_api(desc->apiname, desc->flags[type], &hook_api_itf, hook);
 		break;
 	case Trace_Type_Evt:
 		hook->handler = afb_hook_create_evt(desc->pattern, desc->flags[type], &hook_evt_itf, hook);
 		break;
+	case Trace_Type_Session:
+		hook->handler = afb_hook_create_session(desc->uuid, desc->flags[type], &hook_session_itf, hook);
+		break;
 	case Trace_Type_Global:
 		hook->handler = afb_hook_create_global(desc->flags[type], &hook_global_itf, hook);
 		break;
@@ -1247,7 +1264,7 @@ static void addhook(struct desc *desc, enum trace_type type)
 	}
 
 	/* attach and activate the hook */
-	afb_req_subscribe(desc->context->req, afb_evt_event_from_evtid(hook->event->evtid));
+	afb_req_subscribe(desc->context->req, afb_evt_event_x2_from_evtid(hook->event->evtid));
 	trace_attach_hook(trace, hook, type);
 }
 
@@ -1255,6 +1272,11 @@ static void addhooks(struct desc *desc)
 {
 	int i;
 
+#if !defined(REMOVE_LEGACY_TRACE)
+	desc->flags[Trace_Type_Api] |= desc->flags[Trace_Legacy_Type_Ditf] | desc->flags[Trace_Legacy_Type_Svc];
+	desc->flags[Trace_Legacy_Type_Ditf] = desc->flags[Trace_Legacy_Type_Svc] = 0;
+#endif
+
 	for (i = 0 ; i < Trace_Type_Count ; i++) {
 		if (desc->flags[i])
 			addhook(desc, i);
@@ -1270,7 +1292,7 @@ static void add_flags(void *closure, struct json_object *object, enum trace_type
 	if (wrap_json_unpack(object, "s", &name))
 		ctxt_error(&desc->context->errors, "unexpected %s value %s",
 					abstracting[type].name,
-					json_object_to_json_string(object));
+					json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
 	else {
 		queried = (name[0] == '*' && !name[1]) ? "all" : name;
 		value = abstracting[type].get_flag(queried);
@@ -1287,14 +1309,21 @@ static void add_xreq_flags(void *closure, struct json_object *object)
 	add_flags(closure, object, Trace_Type_Xreq);
 }
 
-static void add_ditf_flags(void *closure, struct json_object *object)
+#if !defined(REMOVE_LEGACY_TRACE)
+static void legacy_add_ditf_flags(void *closure, struct json_object *object)
 {
-	add_flags(closure, object, Trace_Type_Ditf);
+	add_flags(closure, object, Trace_Legacy_Type_Ditf);
 }
 
-static void add_svc_flags(void *closure, struct json_object *object)
+static void legacy_add_svc_flags(void *closure, struct json_object *object)
+{
+	add_flags(closure, object, Trace_Legacy_Type_Svc);
+}
+#endif
+
+static void add_api_flags(void *closure, struct json_object *object)
 {
-	add_flags(closure, object, Trace_Type_Svc);
+	add_flags(closure, object, Trace_Type_Api);
 }
 
 static void add_evt_flags(void *closure, struct json_object *object)
@@ -1302,6 +1331,11 @@ static void add_evt_flags(void *closure, struct json_object *object)
 	add_flags(closure, object, Trace_Type_Evt);
 }
 
+static void add_session_flags(void *closure, struct json_object *object)
+{
+	add_flags(closure, object, Trace_Type_Session);
+}
+
 static void add_global_flags(void *closure, struct json_object *object)
 {
 	add_flags(closure, object, Trace_Type_Global);
@@ -1312,49 +1346,67 @@ static void add(void *closure, struct json_object *object)
 {
 	int rc;
 	struct desc desc;
-	struct json_object *request, *event, *daemon, *service, *sub, *global;
+	struct json_object *request, *event, *sub, *global, *session, *api;
+#if !defined(REMOVE_LEGACY_TRACE)
+	struct json_object *daemon, *service;
+#endif
 
 	memcpy (&desc, closure, sizeof desc);
-	request = event = daemon = service = sub = global = NULL;
+	request = event = sub = global = session = api = NULL;
+#if !defined(REMOVE_LEGACY_TRACE)
+	daemon = service = NULL;
+#endif
 
-	rc = wrap_json_unpack(object, "{s?s s?s s?s s?s s?s s?s s?o s?o s?o s?o s?o s?o}",
+	rc = wrap_json_unpack(object, "{s?s s?s s?s s?s s?s s?s s?o s?o s?o s?o s?o s?o s?o}",
 			"name", &desc.name,
 			"tag", &desc.tag,
-			"api", &desc.api,
-			"verb", &desc.verb,
-			"session", &desc.session,
+			"apiname", &desc.apiname,
+			"verbname", &desc.verbname,
+			"uuid", &desc.uuid,
 			"pattern", &desc.pattern,
+			"api", &api,
 			"request", &request,
+#if !defined(REMOVE_LEGACY_TRACE)
 			"daemon", &daemon,
 			"service", &service,
+#endif
 			"event", &event,
+			"session", &session,
 			"global", &global,
 			"for", &sub);
 
 	if (!rc) {
 		/* replace stars */
-		if (desc.api && desc.api[0] == '*' && !desc.api[1])
-			desc.api = NULL;
+		if (desc.apiname && desc.apiname[0] == '*' && !desc.apiname[1])
+			desc.apiname = NULL;
 
-		if (desc.verb && desc.verb[0] == '*' && !desc.verb[1])
-			desc.verb = NULL;
+		if (desc.verbname && desc.verbname[0] == '*' && !desc.verbname[1])
+			desc.verbname = NULL;
 
-		if (desc.session && desc.session[0] == '*' && !desc.session[1])
-			desc.session = NULL;
+		if (desc.uuid && desc.uuid[0] == '*' && !desc.uuid[1])
+			desc.uuid = NULL;
 
 		/* get what is expected */
 		if (request)
 			wrap_json_optarray_for_all(request, add_xreq_flags, &desc);
 
+		if (api)
+			wrap_json_optarray_for_all(api, add_api_flags, &desc);
+
+#if !defined(REMOVE_LEGACY_TRACE)
 		if (daemon)
-			wrap_json_optarray_for_all(daemon, add_ditf_flags, &desc);
+			wrap_json_optarray_for_all(daemon, legacy_add_ditf_flags, &desc);
 
 		if (service)
-			wrap_json_optarray_for_all(service, add_svc_flags, &desc);
+			wrap_json_optarray_for_all(service, legacy_add_svc_flags, &desc);
+#endif
 
 		if (event)
 			wrap_json_optarray_for_all(event, add_evt_flags, &desc);
 
+		if (session)
+			wrap_json_optarray_for_all(session, add_session_flags, &desc);
+
 		if (global)
 			wrap_json_optarray_for_all(global, add_global_flags, &desc);
 
@@ -1380,7 +1432,7 @@ static void drop_tag(void *closure, struct json_object *object)
 
 	rc = wrap_json_unpack(object, "s", &name);
 	if (rc)
-		ctxt_error(&context->errors, "unexpected tag value %s", json_object_to_json_string(object));
+		ctxt_error(&context->errors, "unexpected tag value %s", json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
 	else {
 		tag = trace_get_tag(context->trace, name, 0);
 		if (!tag)
@@ -1400,7 +1452,7 @@ static void drop_event(void *closure, struct json_object *object)
 
 	rc = wrap_json_unpack(object, "s", &name);
 	if (rc)
-		ctxt_error(&context->errors, "unexpected event value %s", json_object_to_json_string(object));
+		ctxt_error(&context->errors, "unexpected event value %s", json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
 	else {
 		event = trace_get_event(context->trace, name, 0);
 		if (!event)
@@ -1420,7 +1472,7 @@ static void drop_session(void *closure, struct json_object *object)
 
 	rc = wrap_json_unpack(object, "s", &uuid);
 	if (rc)
-		ctxt_error(&context->errors, "unexpected session value %s", json_object_to_json_string(object));
+		ctxt_error(&context->errors, "unexpected session value %s", json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
 	else {
 		session = trace_get_session_by_uuid(context->trace, uuid, 0);
 		if (!session)
@@ -1437,17 +1489,17 @@ static void drop_session(void *closure, struct json_object *object)
 /*******************************************************************************/
 
 /* allocates an afb_trace instance */
-struct afb_trace *afb_trace_create(struct afb_daemon *daemon, struct afb_session *bound)
+struct afb_trace *afb_trace_create(const char *apiname, struct afb_session *bound)
 {
 	struct afb_trace *trace;
 
-	assert(daemon);
+	assert(apiname);
 
 	trace = calloc(1, sizeof *trace);
 	if (trace) {
 		trace->refcount = 1;
 		trace->bound = bound;
-		trace->daemon = daemon;
+		trace->apiname = apiname;
 		pthread_mutex_init(&trace->mutex, NULL);
 	}
 	return trace;
@@ -1472,7 +1524,7 @@ void afb_trace_unref(struct afb_trace *trace)
 }
 
 /* add traces */
-int afb_trace_add(struct afb_req req, struct json_object *args, struct afb_trace *trace)
+int afb_trace_add(afb_req_t req, struct json_object *args, struct afb_trace *trace)
 {
 	struct context context;
 	struct desc desc;
@@ -1497,11 +1549,11 @@ int afb_trace_add(struct afb_req req, struct json_object *args, struct afb_trace
 }
 
 /* drop traces */
-extern int afb_trace_drop(struct afb_req req, struct json_object *args, struct afb_trace *trace)
+int afb_trace_drop(afb_req_t req, struct json_object *args, struct afb_trace *trace)
 {
 	int rc;
 	struct context context;
-	struct json_object *tags, *events, *sessions;
+	struct json_object *tags, *events, *uuids;
 
 	memset(&context, 0, sizeof context);
 	context.trace = trace;
@@ -1518,13 +1570,13 @@ extern int afb_trace_drop(struct afb_req req, struct json_object *args, struct a
 		return 0;
 	}
 
-	tags = events = sessions = NULL;
+	tags = events = uuids = NULL;
 	rc = wrap_json_unpack(args, "{s?o s?o s?o}",
 			"event", &events,
 			"tag", &tags,
-			"session", &sessions);
+			"uuid", &uuids);
 
-	if (rc < 0 || !(events || tags || sessions)) {
+	if (rc < 0 || !(events || tags || uuids)) {
 		afb_req_fail(req, "error-detected", "bad drop arguments");
 		return -1;
 	}
@@ -1537,8 +1589,8 @@ extern int afb_trace_drop(struct afb_req req, struct json_object *args, struct a
 	if (events)
 		wrap_json_optarray_for_all(events, drop_event, &context);
 
-	if (sessions)
-		wrap_json_optarray_for_all(sessions, drop_session, &context);
+	if (uuids)
+		wrap_json_optarray_for_all(uuids, drop_session, &context);
 
 	trace_cleanup(trace);
 
@@ -1552,3 +1604,4 @@ extern int afb_trace_drop(struct afb_req req, struct json_object *args, struct a
 	return -1;
 }
 
+#endif