src/core/lib/debug/trace.cc

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <grpc/support/port_platform.h>
  20
  21 #include "src/core/lib/debug/trace.h"
  22
  23 #include <string.h>
  24 #include <type_traits>
  25
  26 #include <grpc/grpc.h>
  27 #include <grpc/support/alloc.h>
  28 #include <grpc/support/log.h>
  29 #include "src/core/lib/gpr/env.h"
  30
  31 int grpc_tracer_set_enabled(const char* name, int enabled);
  32
  33 namespace grpc_core {
  34
  35 TraceFlag* TraceFlagList::root_tracer_ = nullptr;
  36
  37 bool TraceFlagList::Set(const char* name, bool enabled) {
  38   TraceFlag* t;
  39   if (0 == strcmp(name, "all")) {
  40     for (t = root_tracer_; t; t = t->next_tracer_) {
  41       t->set_enabled(enabled);
  42     }
  43   } else if (0 == strcmp(name, "list_tracers")) {
  44     LogAllTracers();
  45   } else if (0 == strcmp(name, "refcount")) {
  46     for (t = root_tracer_; t; t = t->next_tracer_) {
  47       if (strstr(t->name_, "refcount") != nullptr) {
  48         t->set_enabled(enabled);
  49       }
  50     }
  51   } else {
  52     bool found = false;
  53     for (t = root_tracer_; t; t = t->next_tracer_) {
  54       if (0 == strcmp(name, t->name_)) {
  55         t->set_enabled(enabled);
  56         found = true;
  57       }
  58     }
  59     // check for unknowns, but ignore "", to allow to GRPC_TRACE=
  60     if (!found && 0 != strcmp(name, "")) {
  61       gpr_log(GPR_ERROR, "Unknown trace var: '%s'", name);
  62       return false; /* early return */
  63     }
  64   }
  65   return true;
  66 }
  67
  68 void TraceFlagList::Add(TraceFlag* flag) {
  69   flag->next_tracer_ = root_tracer_;
  70   root_tracer_ = flag;
  71 }
  72
  73 void TraceFlagList::LogAllTracers() {
  74   gpr_log(GPR_DEBUG, "available tracers:");
  75   TraceFlag* t;
  76   for (t = root_tracer_; t != nullptr; t = t->next_tracer_) {
  77     gpr_log(GPR_DEBUG, "\t%s", t->name_);
  78   }
  79 }
  80
  81 // Flags register themselves on the list during construction
  82 TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
  83   static_assert(std::is_trivially_destructible<TraceFlag>::value,
  84                 "TraceFlag needs to be trivially destructible.");
  85   set_enabled(default_enabled);
  86   TraceFlagList::Add(this);
  87 }
  88
  89 }  // namespace grpc_core
  90
  91 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
  92   size_t n = *ns;
  93   size_t np = n + 1;
  94   char* s;
  95   size_t len;
  96   GPR_ASSERT(end >= beg);
  97   len = static_cast<size_t>(end - beg);
  98   s = static_cast<char*>(gpr_malloc(len + 1));
  99   memcpy(s, beg, len);
 100   s[len] = 0;
 101   *ss = static_cast<char**>(gpr_realloc(*ss, sizeof(char**) * np));
 102   (*ss)[n] = s;
 103   *ns = np;
 104 }
 105
 106 static void split(const char* s, char*** ss, size_t* ns) {
 107   const char* c = strchr(s, ',');
 108   if (c == nullptr) {
 109     add(s, s + strlen(s), ss, ns);
 110   } else {
 111     add(s, c, ss, ns);
 112     split(c + 1, ss, ns);
 113   }
 114 }
 115
 116 static void parse(const char* s) {
 117   char** strings = nullptr;
 118   size_t nstrings = 0;
 119   size_t i;
 120   split(s, &strings, &nstrings);
 121
 122   for (i = 0; i < nstrings; i++) {
 123     if (strings[i][0] == '-') {
 124       grpc_core::TraceFlagList::Set(strings[i] + 1, false);
 125     } else {
 126       grpc_core::TraceFlagList::Set(strings[i], true);
 127     }
 128   }
 129
 130   for (i = 0; i < nstrings; i++) {
 131     gpr_free(strings[i]);
 132   }
 133   gpr_free(strings);
 134 }
 135
 136 void grpc_tracer_init(const char* env_var) {
 137   char* e = gpr_getenv(env_var);
 138   if (e != nullptr) {
 139     parse(e);
 140     gpr_free(e);
 141   }
 142 }
 143
 144 void grpc_tracer_shutdown(void) {}
 145
 146 int grpc_tracer_set_enabled(const char* name, int enabled) {
 147   return grpc_core::TraceFlagList::Set(name, enabled != 0);
 148 }