Add tracing macros to addressresolve

examples/chip-tool/BUILD.gn

@@ -101,6 +101,7 @@ static_library("chip-tool-utils") {
   }
 
   public_deps = [
+    "${chip_root}/examples/common/tracing:commandline",
     "${chip_root}/src/app/server",
     "${chip_root}/src/app/tests/suites/commands/commissioner",
     "${chip_root}/src/app/tests/suites/commands/delay",
@@ -114,8 +115,6 @@ static_library("chip-tool-utils") {
     "${chip_root}/src/lib",
     "${chip_root}/src/lib/support/jsontlv",
     "${chip_root}/src/platform",
-    "${chip_root}/src/tracing",
-    "${chip_root}/src/tracing/log_json",
     "${chip_root}/third_party/inipp",
     "${chip_root}/third_party/jsoncpp",
   ]

examples/chip-tool/commands/common/CHIPCommand.cpp

@@ -18,6 +18,7 @@
 
 #include "CHIPCommand.h"
 
+#include <TracingCommandLineArgument.h>
 #include <controller/CHIPDeviceControllerFactory.h>
 #include <core/CHIPBuildConfig.h>
 #include <credentials/attestation_verifier/FileAttestationTrustStore.h>
@@ -26,9 +27,6 @@
 #include <lib/support/ScopedBuffer.h>
 #include <lib/support/TestGroupData.h>
 
-#include <tracing/log_json/log_json_tracing.h>
-#include <tracing/registry.h>
-
 #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
 #include "TraceDecoder.h"
 #include "TraceHandlers.h"
@@ -82,15 +80,6 @@ CHIP_ERROR GetAttestationTrustStore(const char * paaTrustStorePath, const chip::
     return CHIP_NO_ERROR;
 }
 
-using ::chip::Tracing::ScopedRegistration;
-using ::chip::Tracing::LogJson::LogJsonBackend;
-
-LogJsonBackend log_json_backend;
-
-// ScopedRegistration ensures register/unregister is met, as long
-// as the vector is cleared (and we do so when stopping tracing).
-std::vector<std::unique_ptr<ScopedRegistration>> tracing_backends;
-
 } // namespace
 
 CHIP_ERROR CHIPCommand::MaybeSetUpStack()
@@ -258,17 +247,7 @@ void CHIPCommand::StartTracing()
     {
         for (const auto & destination : mTraceTo.Value())
         {
-            if (destination == "log")
-            {
-                if (!log_json_backend.IsInList())
-                {
-                    tracing_backends.push_back(std::make_unique<ScopedRegistration>(log_json_backend));
-                }
-            }
-            else
-            {
-                ChipLogError(AppServer, "Unknown trace destination: '%s'", destination.c_str());
-            }
+            chip::CommandLineApp::EnableTracingFor(destination.c_str());
         }
     }
 
@@ -298,7 +277,7 @@ void CHIPCommand::StartTracing()
 
 void CHIPCommand::StopTracing()
 {
-    tracing_backends.clear();
+    chip::CommandLineApp::StopTracing();
 
 #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
     chip::trace::DeInitTrace();

examples/chip-tool/commands/common/CHIPCommand.h

@@ -24,6 +24,7 @@
 
 #include "Command.h"
 
+#include <TracingCommandLineArgument.h>
 #include <commands/common/CredentialIssuerCommands.h>
 #include <commands/example/ExampleCredentialIssuerCommands.h>
 #include <credentials/GroupDataProviderImpl.h>
@@ -85,7 +86,7 @@ class CHIPCommand : public Command
         AddArgument("trace_log", 0, 1, &mTraceLog);
         AddArgument("trace_decode", 0, 1, &mTraceDecode);
 #endif // CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
-        AddArgument("trace-to", &mTraceTo, "Trace destinations, comma-separated (e.g. log)");
+        AddArgument("trace-to", &mTraceTo, "Trace destinations, comma-separated (" SUPPORTED_COMMAND_LINE_TRACING_TARGETS ")");
         AddArgument("ble-adapter", 0, UINT16_MAX, &mBleAdapterId);
         AddArgument("storage-directory", &mStorageDirectory,
                     "Directory to place chip-tool's storage files in.  Defaults to $TMPDIR, with fallback to /tmp");

examples/common/tracing/BUILD.gn

@@ -20,6 +20,23 @@ config("default_config") {
   include_dirs = [ "." ]
 }
 
+source_set("commandline") {
+  sources = [
+    "TracingCommandLineArgument.cpp",
+    "TracingCommandLineArgument.h",
+  ]
+
+  deps = [
+    "${chip_root}/src/lib/support",
+    "${chip_root}/src/tracing",
+    "${chip_root}/src/tracing/log_json",
+  ]
+
+  public_configs = [ ":default_config" ]
+
+  cflags = [ "-Wconversion" ]
+}
+
 source_set("trace_handlers") {
   sources = [ "TraceHandlers.cpp" ]
 

examples/common/tracing/TraceHandlers.cpp

@@ -22,17 +22,18 @@
 #include <string>
 #include <vector>
 
-#include "transport/TraceMessage.h"
 #include <lib/support/BytesToHex.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/logging/CHIPLogging.h>
+#include <transport/TraceMessage.h>
 
 // For `s` std::string literal suffix
 using namespace std::string_literals;
 
 namespace chip {
 namespace trace {
 
+#if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
 namespace {
 
 // Handles the output from the trace handlers.
@@ -350,5 +351,11 @@ void DeInitTrace()
     gTraceOutputs.UnregisterAllStreams();
 }
 
+#else
+void AddTraceStream(TraceStream *) {}
+void InitTrace() {}
+void DeInitTrace() {}
+#endif // CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
+
 } // namespace trace
 } // namespace chip

examples/common/tracing/TracingCommandLineArgument.cpp

@@ -0,0 +1,72 @@
+/*
+ *
+ *    Copyright (c) 2023 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#include <TracingCommandLineArgument.h>
+
+#include <lib/support/StringSplitter.h>
+#include <lib/support/logging/CHIPLogging.h>
+#include <tracing/log_json/log_json_tracing.h>
+#include <tracing/registry.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace chip {
+namespace CommandLineApp {
+
+namespace {
+using ::chip::Tracing::ScopedRegistration;
+using ::chip::Tracing::LogJson::LogJsonBackend;
+
+// currently supported backends
+LogJsonBackend log_json_backend;
+
+// ScopedRegistration ensures register/unregister is met, as long
+// as the vector is cleared (and we do so when stopping tracing).
+std::vector<std::unique_ptr<ScopedRegistration>> tracing_backends;
+
+} // namespace
+
+void EnableTracingFor(const char * cliArg)
+{
+    chip::StringSplitter splitter(cliArg, ',');
+    chip::CharSpan value;
+
+    while (splitter.Next(value))
+    {
+        if (value.data_equal(CharSpan::fromCharString("log")))
+        {
+            if (!log_json_backend.IsInList())
+            {
+                tracing_backends.push_back(std::make_unique<ScopedRegistration>(log_json_backend));
+            }
+        }
+        else
+        {
+            ChipLogError(AppServer, "Unknown trace destination: '%s'", std::string(value.data(), value.size()).c_str());
+        }
+    }
+}
+
+void StopTracing()
+{
+    tracing_backends.clear();
+}
+
+} // namespace CommandLineApp
+} // namespace chip

examples/common/tracing/TracingCommandLineArgument.h

@@ -0,0 +1,41 @@
+/*
+ *
+ *    Copyright (c) 2023 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#pragma once
+
+/// A string with supported command line tracing targets
+/// to be pretty-printed in help strings if needed
+#define SUPPORTED_COMMAND_LINE_TRACING_TARGETS "log"
+
+namespace chip {
+namespace CommandLineApp {
+
+/// Enable tracing based on the given command line argument
+/// like "log" or "log,perfetto" or similar
+///
+/// Single arguments as well as comma separated ones are accepted.
+///
+/// Calling this method multiple times is ok and will enable each of
+/// the given tracing modules if not already enabled.
+void EnableTracingFor(const char * cliArg);
+
+/// If EnableTracingFor is called, this MUST be called as well
+/// to unregister tracing backends
+void StopTracing();
+
+} // namespace CommandLineApp
+} // namespace chip

examples/minimal-mdns/BUILD.gn

@@ -36,6 +36,7 @@ executable("minimal-mdns-client") {
 
   deps = [
     ":minimal-mdns-example-common",
+    "${chip_root}/examples/common/tracing:commandline",
     "${chip_root}/src/lib",
     "${chip_root}/src/lib/dnssd/minimal_mdns",
   ]
@@ -50,6 +51,7 @@ executable("minimal-mdns-server") {
 
   deps = [
     ":minimal-mdns-example-common",
+    "${chip_root}/examples/common/tracing:commandline",
     "${chip_root}/src/lib",
     "${chip_root}/src/lib/dnssd/minimal_mdns",
     "${chip_root}/src/lib/dnssd/minimal_mdns/responders",
@@ -65,6 +67,7 @@ executable("mdns-advertiser") {
 
   deps = [
     ":minimal-mdns-example-common",
+    "${chip_root}/examples/common/tracing:commandline",
     "${chip_root}/src/lib",
     "${chip_root}/src/lib/dnssd",
   ]

examples/minimal-mdns/advertiser.cpp

@@ -20,6 +20,7 @@
 #include <arpa/inet.h>
 #include <strings.h>
 
+#include <TracingCommandLineArgument.h>
 #include <lib/dnssd/Advertiser.h>
 #include <lib/support/CHIPArgParser.hpp>
 #include <lib/support/CHIPMem.h>
@@ -81,6 +82,7 @@ constexpr uint16_t kOptionCommissioningRotatingId         = 0x700;
 
 constexpr uint16_t kOptionOperationalFabricId = 'f';
 constexpr uint16_t kOptionOperationalNodeId   = 'n';
+constexpr uint16_t kOptionTraceTo             = 't';
 
 bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue)
 {
@@ -90,6 +92,9 @@ bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier,
     case kOptionEnableIpV4:
         gOptions.enableIpV4 = true;
         return true;
+    case kOptionTraceTo:
+        CommandLineApp::EnableTracingFor(aValue);
+        return true;
     case kOptionAdvertisingMode:
         if (strcmp(aValue, "operational") == 0)
         {
@@ -187,6 +192,7 @@ OptionDef cmdLineOptionsDef[] = {
 
     { "fabric-id", kArgumentRequired, kOptionOperationalFabricId },
     { "node-id", kArgumentRequired, kOptionOperationalNodeId },
+    { "trace-to", kArgumentRequired, kOptionTraceTo },
     {},
 };
 
@@ -228,12 +234,20 @@ OptionSet cmdLineOptions = { HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS"
                              "  --node-id <value>\n"
                              "  -n <value>\n"
                              "        Operational node id.\n"
+                             "  -t <dest>\n"
+                             "  --trace-to <dest>\n"
+                             "        trace to the given destination (supported: " SUPPORTED_COMMAND_LINE_TRACING_TARGETS ").\n"
                              "\n" };
 
 HelpOptions helpOptions("advertiser", "Usage: advertiser [options]", "1.0");
 
 OptionSet * allOptions[] = { &cmdLineOptions, &helpOptions, nullptr };
 
+void StopSignalHandler(int signal)
+{
+    DeviceLayer::PlatformMgr().StopEventLoopTask();
+}
+
 } // namespace
 
 int main(int argc, char ** args)
@@ -316,8 +330,15 @@ int main(int argc, char ** args)
         return 1;
     }
 
+    signal(SIGTERM, StopSignalHandler);
+    signal(SIGINT, StopSignalHandler);
+
     DeviceLayer::PlatformMgr().RunEventLoop();
 
+    CommandLineApp::StopTracing();
+    Dnssd::Resolver::Instance().Shutdown();
+    DeviceLayer::PlatformMgr().Shutdown();
+
     printf("Done...\n");
     return 0;
 }