get grpc logging working

Author: stuqdog

src/viam/examples/modules/complex/client.cpp

@@ -27,27 +27,36 @@
 using namespace viam::sdk;
 
 int main() {
-    const char* uri = "http://localhost:8080/";  // replace with your URI if connecting securely
-    DialOptions dial_options;
-    dial_options.set_allow_insecure_downgrade(true);  // set to false if connecting securely
+    // const char* uri = "http://localhost:8080/";  // replace with your URI if connecting securely
+    // DialOptions dial_options;
+    // dial_options.set_allow_insecure_downgrade(true);  // set to false if connecting securely
 
     // Uncomment and fill out your credentials details if connecting securely
     // std::string type = "<your authentication type>";
     // std::string payload = "<your authentication payload>";
     // Credentials credentials(type, payload);
     // dial_options.set_credentials(credentials);
 
-    boost::optional<DialOptions> opts(dial_options);
-    std::string address(uri);
-    Options options(1, opts);
+    std::string host("webrtc-test-main.jkek76kqnh.viam.cloud");
+    DialOptions dial_opts;
+    dial_opts.set_entity(std::string("a9dcf212-3397-4318-bb1e-f5c36b3cafc1"));
+    Credentials credentials("api-key", "2ml60ys1j4i9v0pecpxahe654yxpc1dz");
+    dial_opts.set_credentials(credentials);
+    boost::optional<DialOptions> opts(dial_opts);
+    Options options(0, opts);
+
+    // boost::optional<DialOptions> opts(dial_options);
+    // std::string address(uri);
+    // Options options(1, opts);
 
     // Register custom gizmo and summation clients so robot client can access resources
     // of that type from the server.
     Registry::register_resource_client<GizmoClient>();
     Registry::register_resource_client<SummationClient>();
+    std::cout << "We are here!!!!\n\n\n" << std::flush;
 
     // Connect to robot.
-    std::shared_ptr<RobotClient> robot = RobotClient::at_address(address, options);
+    std::shared_ptr<RobotClient> robot = RobotClient::at_address(host, options);
     // Print resources.
     std::cout << "Resources" << std::endl;
     std::vector<Name> resource_names = robot->resource_names();

src/viam/examples/modules/complex/gizmo/api.cpp

@@ -4,6 +4,9 @@
 
 #include <google/protobuf/descriptor.h>
 
+#include <boost/log/common.hpp>
+#include <boost/log/sources/logger.hpp>
+#include <boost/log/trivial.hpp>
 #include <viam/sdk/common/client_helper.hpp>
 #include <viam/sdk/common/utils.hpp>
 #include <viam/sdk/registry/registry.hpp>
@@ -24,12 +27,22 @@ API API::traits<Gizmo>::api() {
     return {"viam", "component", "gizmo"};
 }
 
-Gizmo::Gizmo(std::string name) : Component(std::move(name)){};
+Gizmo::Gizmo(std::string name)
+    : Component(std::move(name)) {
+          // boost::log::sources::severity_logger<boost::log::trivial::severity_level> lg;
+          // BOOST_LOG_SEV(lg, boost::log::trivial::severity_level::debug) << "debug test";
+          // BOOST_LOG_SEV(lg, boost::log::trivial::severity_level::info) << "info test";
+          // BOOST_LOG_SEV(lg, boost::log::trivial::severity_level::warning) << "warning test";
+          // BOOST_LOG_SEV(lg, boost::log::trivial::severity_level::error) << "error test";
+          // BOOST_LOG_TRIVIAL(error) << "gizmo created error\n";
+          // BOOST_LOG_TRIVIAL(info) << "gizmo created info\n";
+          // BOOST_LOG_TRIVIAL(debug) << "gizmo created debug\n";
+      };
 
 /* Gizmo server methods */
 
 GizmoServer::GizmoServer(std::shared_ptr<ResourceManager> manager)
-    : ResourceServer(std::move(manager)){};
+    : ResourceServer(std::move(manager)) {};
 
 grpc::Status GizmoServer::DoOne(grpc::ServerContext* context,
                                 const DoOneRequest* request,
@@ -170,12 +183,25 @@ grpc::Status GizmoServer::DoTwo(::grpc::ServerContext* context,
 /* Gizmo client methods */
 
 GizmoClient::GizmoClient(std::string name, std::shared_ptr<grpc::Channel> channel)
-    : Gizmo(std::move(name)), stub_(GizmoService::NewStub(channel)), channel_(std::move(channel)){};
+    : Gizmo(std::move(name)),
+      stub_(GizmoService::NewStub(channel)),
+      channel_(std::move(channel)) {};
 
 bool GizmoClient::do_one(std::string arg1) {
+    BOOST_LOG_SEV(*(logger_.underlying()), boost::log::trivial::severity_level::error)
+        << "some other new error log";
+    logger_.info("new info log");
+    logger_.debug("new debug log");
+    logger_.error("new error log");
     return make_client_helper(this, *stub_, &StubType::DoOne)
-        .with([&](auto& request) { request.set_arg1(arg1); })
-        .invoke([](auto& response) { return response.ret1(); });
+        .with([&](auto& request) {
+            std::cout << "in with\n" << std::flush;
+            request.set_arg1(arg1);
+        })
+        .invoke([](auto& response) {
+            std::cout << "in invoke\n" << std::flush;
+            return response.ret1();
+        });
 }
 
 bool GizmoClient::do_one_client_stream(std::vector<std::string> arg1) {

src/viam/examples/modules/complex/gizmo/impl.cpp

@@ -13,8 +13,8 @@
 
 using namespace viam::sdk;
 
-std::string find_arg1(ResourceConfig cfg) {
-    auto gizmo_name = cfg.name();
+std::string find_arg1(const ResourceConfig& cfg) {
+    const auto& gizmo_name = cfg.name();
     auto arg1 = cfg.attributes().find("arg1");
     if (arg1 == cfg.attributes().end()) {
         std::ostringstream buffer;
@@ -31,11 +31,11 @@ std::string find_arg1(ResourceConfig cfg) {
     return *arg1_string;
 }
 
-void MyGizmo::reconfigure(const Dependencies& deps, const ResourceConfig& cfg) {
+void MyGizmo::reconfigure(const Dependencies&, const ResourceConfig& cfg) {
     arg1_ = find_arg1(cfg);
 }
 
-std::vector<std::string> MyGizmo::validate(ResourceConfig cfg) {
+std::vector<std::string> MyGizmo::validate(const ResourceConfig& cfg) {
     // Custom validation can be done by specifying a validate function at the
     // time of resource registration (see complex/main.cpp) like this one.
     // Validate functions can `throw` exceptions that will be returned to the
@@ -50,6 +50,14 @@ std::vector<std::string> MyGizmo::validate(ResourceConfig cfg) {
 }
 
 bool MyGizmo::do_one(std::string arg1) {
+    std::cout << "it's a myGizmo!";
+    // CR erodkin: these logs break things when init_logging_() is called. figure out why!
+    // also we're now getting an error when stopping the viam-server that the mod manager didn't
+    // close properly so probably we should figure that out too
+    // logger_.error("new error log in do_one");
+    logger_.debug("new debug log in do_one");
+    std::cout << "did a debug log now let's try an info one \n" << std::flush;
+    logger_.info("new info log in do_one");
     return arg1_ == arg1;
 }
 

src/viam/examples/modules/complex/gizmo/impl.hpp

@@ -14,12 +14,12 @@ using namespace viam::sdk;
 // `validate` method that checks config validity.
 class MyGizmo : public Gizmo, public Reconfigurable {
    public:
-    MyGizmo(std::string name, std::string arg1) : Gizmo(std::move(name)), arg1_(std::move(arg1)){};
+    MyGizmo(std::string name, std::string arg1) : Gizmo(std::move(name)), arg1_(std::move(arg1)) {};
     MyGizmo(const Dependencies& deps, const ResourceConfig& cfg) : Gizmo(cfg.name()) {
         this->reconfigure(deps, cfg);
     };
     void reconfigure(const Dependencies& deps, const ResourceConfig& cfg) override;
-    static std::vector<std::string> validate(ResourceConfig cfg);
+    static std::vector<std::string> validate(const ResourceConfig& cfg);
 
     bool do_one(std::string arg1) override;
     bool do_one_client_stream(std::vector<std::string> arg1) override;

src/viam/examples/modules/complex/main.cpp

@@ -30,6 +30,8 @@ using namespace viam::sdk;
 int main(int argc, char** argv) {
     Model mybase_model("viam", "base", "mybase");
 
+    std::cout << "registering resource servers\n" << std::flush;
+
     // Make sure to explicity register resources with custom APIs.
     Registry::register_resource_server<GizmoServer>();
     Registry::register_resource_server<SummationServer>();
@@ -56,6 +58,7 @@ int main(int argc, char** argv) {
 
     std::vector<std::shared_ptr<ModelRegistration>> mrs = {mybase_mr, mygizmo_mr, mysummation_mr};
     auto my_mod = std::make_shared<ModuleService>(argc, argv, mrs);
+    std::cout << "we have created the module and gotten ready to serve\n" << std::flush;
     my_mod->serve();
 
     return EXIT_SUCCESS;

src/viam/sdk/CMakeLists.txt

@@ -49,6 +49,7 @@ target_sources(viamsdk
     common/client_helper.cpp
     common/exception.cpp
     common/linear_algebra.cpp
+    common/logger.cpp
     common/pose.cpp
     common/proto_value.cpp
     common/service_helper.cpp
@@ -137,6 +138,7 @@ target_sources(viamsdk
       ../../viam/sdk/common/client_helper.hpp
       ../../viam/sdk/common/exception.hpp
       ../../viam/sdk/common/linear_algebra.hpp
+      ../../viam/sdk/common/logger.hpp
       ../../viam/sdk/common/pose.hpp
       ../../viam/sdk/common/proto_value.hpp
       ../../viam/sdk/common/service_helper.hpp

src/viam/sdk/common/client_helper.hpp

@@ -35,6 +35,9 @@ class ClientHelper {
     static void default_rsc_(RequestType&) {}
     static void default_rhc_(const ResponseType&) {}
     static void default_ehc_(const ::grpc::Status& status) {
+        std::cout << "error is " << status.error_details() << " " << status.error_code() << " "
+                  << status.error_message() << "\n"
+                  << std::flush;
         throw GRPCException(status);
     }
 
@@ -76,8 +79,11 @@ class ClientHelper {
         if (debug_key_ != "") {
             ctx.set_debug_key(debug_key_);
         }
+        std::cout << "getting result\n" << std::flush;
         const auto result = (stub_->*pfn_)(ctx, request_, &response_);
+        std::cout << "got result\n" << std::flush;
         if (result.ok()) {
+            std::cout << "got bad result\n" << std::flush;
             return std::forward<ResponseHandlerCallable>(rhc)(
                 const_cast<const ResponseType&>(response_));
         }

src/viam/sdk/common/logger.cpp

@@ -0,0 +1,86 @@
+#include <viam/sdk/common/logger.hpp>
+
+#include <iostream>
+
+#include <boost/log/core.hpp>
+#include <boost/log/trivial.hpp>
+
+namespace viam {
+namespace sdk {
+
+namespace logging = boost::log;
+using ll = Logger::log_level;
+using bll = logging::trivial::severity_level;
+
+struct Logger::impl {
+    impl()
+        : logger_(std::make_shared<logging::sources::severity_logger<bll>>()), level_(ll::info) {}
+    impl(ll level)
+        : logger_(std::make_shared<logging::sources::severity_logger<bll>>()), level_(level) {}
+
+    std::shared_ptr<logging::sources::severity_logger<bll>> logger_;
+    ll level_;
+};
+
+std::shared_ptr<logging::sources::severity_logger<bll>> Logger::underlying() {
+    return impl_->logger_;
+}
+
+Logger::Logger(std::string name)
+    : name_(std::move(name)), level_(log_level::info), impl_(std::make_unique<impl>()) {};
+Logger::Logger(std::string name, log_level level)
+    : name_(std::move(name)), level_(level), impl_(std::make_unique<impl>(level)) {};
+
+logging::trivial::severity_level _log_level_to_severity_level(Logger::log_level level) {
+    switch (level) {
+        case ll::error: {
+            return bll::error;
+        }
+        case ll::warning: {
+            return bll::warning;
+        }
+        case ll::debug: {
+            return bll::debug;
+        }
+        case ll::fatal: {
+            return bll::fatal;
+        }
+        case ll::trace: {
+            return bll::trace;
+        }
+        case ll::info:  // fallthrough
+        default: {
+            return bll::info;
+        }
+    }
+}
+
+void Logger::log(const std::string& log, log_level level) const {
+    if (impl_->level_ > level) {
+        return;
+    }
+    BOOST_LOG_SEV(*(impl_->logger_), _log_level_to_severity_level(level)) << log;
+}
+void Logger::debug(const std::string& log) const {
+    this->log(log, ll::debug);
+}
+void Logger::error(const std::string& log) const {
+    this->log(log, ll::error);
+}
+void Logger::fatal(const std::string& log) const {
+    this->log(log, ll::fatal);
+}
+void Logger::info(const std::string& log) const {
+    this->log(log, ll::info);
+}
+void Logger::trace(const std::string& log) const {
+    this->log(log, ll::trace);
+}
+void Logger::warning(const std::string& log) const {
+    this->log(log, ll::warning);
+}
+
+Logger::~Logger() = default;
+
+}  // namespace sdk
+}  // namespace viam

src/viam/sdk/common/logger.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <boost/log/core.hpp>
+#include <boost/log/trivial.hpp>
+#include <cstdint>
+#include <string>
+
+namespace viam {
+namespace sdk {
+
+class Resource;
+
+class Logger {
+   public:
+    ~Logger();
+    enum class log_level : std::int8_t {
+        trace = -2,
+        debug = -1,
+        info = 0,  // default value is info
+        warning = 1,
+        error = 2,
+        fatal = 3,
+    };
+
+    explicit Logger(std::string name);
+    explicit Logger(std::string name, log_level level);
+
+    void log(const std::string& log, log_level level) const;
+    void debug(const std::string& log) const;
+    void error(const std::string& log) const;
+    void fatal(const std::string& log) const;
+    void info(const std::string& log) const;
+    void trace(const std::string& log) const;
+    void warning(const std::string& log) const;
+
+    void set_log_level(log_level level);
+
+    std::shared_ptr<boost::log::sources::severity_logger<boost::log::trivial::severity_level>>
+    underlying();
+
+   private:
+    std::string name_;
+    log_level level_;
+    struct impl;
+    std::unique_ptr<impl> impl_;
+};
+
+}  // namespace sdk
+}  // namespace viam

src/viam/sdk/common/utils.cpp

@@ -1,3 +1,4 @@
+#include <chrono>
 #include <viam/sdk/common/utils.hpp>
 
 #include <random>
@@ -40,6 +41,17 @@ time_point timestamp_to_time_pt(const google::protobuf::Timestamp& timestamp) {
                       nanos);
 }
 
+google::protobuf::Timestamp time_pt_to_timestamp(
+    const std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>& time_pt) {
+    const std::chrono::seconds duration_s =
+        std::chrono::duration_cast<std::chrono::seconds>(time_pt.time_since_epoch());
+    const std::chrono::nanoseconds duration_ns = time_pt.time_since_epoch() - duration_s;
+    google::protobuf::Timestamp timestamp;
+    timestamp.set_seconds(duration_s.count());
+    timestamp.set_nanos(static_cast<int32_t>(duration_ns.count()));
+    return timestamp;
+}
+
 google::protobuf::Timestamp time_pt_to_timestamp(const time_point& time_pt) {
     const std::chrono::seconds duration_s =
         std::chrono::duration_cast<std::chrono::seconds>(time_pt.time_since_epoch());