Add grpc-tags-bin propagation helpers. (#414)

Author: g-easy

opencensus/tags/BUILD

@@ -15,6 +15,7 @@
 # limitations under the License.
 
 load("//opencensus:copts.bzl", "DEFAULT_COPTS", "TEST_COPTS")
+load("//bazel:cc_fuzz_target.bzl", "cc_fuzz_target")
 
 licenses(["notice"])  # Apache License 2.0
 
@@ -54,6 +55,18 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "grpc_tags_bin",
+    srcs = ["internal/grpc_tags_bin.cc"],
+    hdrs = ["propagation/grpc_tags_bin.h"],
+    copts = DEFAULT_COPTS,
+    visibility = ["//visibility:public"],
+    deps = [
+        ":tags",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
 cc_library(
     name = "with_tag_map",
     srcs = ["internal/with_tag_map.cc"],
@@ -82,6 +95,18 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "grpc_tags_bin_test",
+    srcs = ["internal/grpc_tags_bin_test.cc"],
+    copts = TEST_COPTS,
+    deps = [
+        ":grpc_tags_bin",
+        ":tags",
+        "@com_google_absl//absl/strings",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_test(
     name = "tag_key_test",
     srcs = ["internal/tag_key_test.cc"],
@@ -119,6 +144,20 @@ cc_test(
 # Benchmarks
 # ========================================================================= #
 
+cc_binary(
+    name = "grpc_tags_bin_benchmark",
+    testonly = 1,
+    srcs = ["internal/grpc_tags_bin_benchmark.cc"],
+    copts = TEST_COPTS,
+    linkstatic = 1,
+    deps = [
+        ":grpc_tags_bin",
+        ":tags",
+        "@com_github_google_benchmark//:benchmark",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
 cc_binary(
     name = "tag_map_benchmark",
     testonly = 1,
@@ -144,3 +183,16 @@ cc_binary(
         "@com_github_google_benchmark//:benchmark",
     ],
 )
+
+# Fuzzers
+# ========================================================================= #
+
+cc_fuzz_target(
+    name = "grpc_tags_bin_fuzzer",
+    srcs = ["internal/grpc_tags_bin_fuzzer.cc"],
+    corpus = glob(["internal/grpc_tags_bin_corpus/*"]),
+    deps = [
+        ":grpc_tags_bin",
+        "@com_google_absl//absl/strings",
+    ],
+)

opencensus/tags/CMakeLists.txt

@@ -33,6 +33,15 @@ opencensus_lib(
   tags
   context)
 
+opencensus_lib(
+  tags_grpc_tags_bin
+  PUBLIC
+  SRCS
+  internal/grpc_tags_bin.cc
+  DEPS
+  tags
+  absl::strings)
+
 opencensus_lib(
   tags_with_tag_map
   PUBLIC
@@ -46,12 +55,22 @@ opencensus_lib(
 opencensus_test(tags_context_util_test internal/context_util_test.cc tags
                 tags_context_util tags_with_tag_map context)
 
+opencensus_test(tags_grpc_tags_bin_test internal/grpc_tags_bin_test.cc tags
+                tags_grpc_tags_bin)
+
 opencensus_test(tags_tag_key_test internal/tag_key_test.cc tags)
 
 opencensus_test(tags_tag_map_test internal/tag_map_test.cc tags)
 
 opencensus_test(tags_with_tag_map_test internal/with_tag_map_test.cc tags
                 tags_with_tag_map context)
 
+opencensus_benchmark(
+  tags_grpc_tags_bin_benchmark internal/grpc_tags_bin_benchmark.cc tags
+  tags_grpc_tags_bin absl::strings)
+
 opencensus_benchmark(tags_tag_map_benchmark internal/tag_map_benchmark.cc tags
                      absl::strings)
+
+opencensus_fuzzer(tags_grpc_tags_bin_fuzzer internal/grpc_tags_bin_fuzzer.cc
+                  tags_grpc_tags_bin absl::strings)

opencensus/tags/internal/grpc_tags_bin.cc

@@ -0,0 +1,158 @@
+// Copyright 2019, OpenCensus Authors
+//
+// 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 "opencensus/tags/propagation/grpc_tags_bin.h"
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "opencensus/tags/tag_key.h"
+#include "opencensus/tags/tag_map.h"
+
+namespace opencensus {
+namespace tags {
+namespace propagation {
+
+namespace {
+
+constexpr char kVersionId = '\0';
+constexpr char kTagFieldId = '\0';
+constexpr int kMaxLen = 8192;
+
+// Appends a variable-length encoded integer to the destination string.
+void AppendVarint(unsigned int i, std::string* out) {
+  do {
+    // Encode 7 bits.
+    uint8_t c = i & 0x7F;
+    i = i >> 7;
+    if (i != 0) {
+      c |= 0x80;
+    }
+    out->push_back(c);
+  } while (i != 0);
+}
+
+// Parses a variable-length encoded integer from the input. Returns false on
+// failure. Returns true and consumes the bytes from the input, on success.
+bool ParseVarint(absl::string_view* input, int* out) {
+  absl::string_view s = *input;
+  int i = 0;
+  uint8_t c;
+  do {
+    if (s.empty()) {
+      return false;  // Too short.
+    }
+    c = s[0];
+    s = s.substr(1);
+    i = (i << 7) | (c & 0x7F);
+  } while (c & 0x80);
+  *input = s;
+  *out = i;
+  return true;
+}
+
+}  // namespace
+
+bool FromGrpcTagsBinHeader(absl::string_view header, TagMap* out) {
+  std::unordered_map<std::string, absl::string_view> keys_vals;
+  if (header.length() < 1) {
+    return false;  // Too short.
+  }
+  if (header.length() > kMaxLen) {
+    return false;  // Too long.
+  }
+  if (header[0] != kVersionId) {
+    return false;  // Wrong version.
+  }
+  header = header.substr(1);
+  while (header.length() > 0) {
+    // Parse tag field id.
+    if (header[0] != kTagFieldId) {
+      return false;  // Wrong field id.
+    }
+    header = header.substr(1);
+
+    // Parse key.
+    absl::string_view key;
+    {
+      int key_len;
+      if (!ParseVarint(&header, &key_len)) {
+        return false;  // Invalid key_len.
+      }
+      if (key_len > header.length()) {
+        return false;  // Key len longer than remaining buffer.
+      }
+      key = header.substr(0, key_len);
+      header = header.substr(key_len);
+    }
+
+    // Parse val.
+    absl::string_view val;
+    {
+      int val_len;
+      if (!ParseVarint(&header, &val_len)) {
+        return false;  // Invalid val_len.
+      }
+      if (val_len > header.length()) {
+        return false;  // Val len longer than remaining buffer.
+      }
+      val = header.substr(0, val_len);
+      header = header.substr(val_len);
+    }
+
+    // Drop empty keys.
+    if (!key.empty()) {
+      // For duplicate keys, last wins.
+      keys_vals[std::string(key)] = val;
+    }
+  }
+
+  // Convert to tagmap.
+  std::vector<std::pair<opencensus::tags::TagKey, std::string>> tags;
+  tags.reserve(keys_vals.size());
+  for (const auto& kv : keys_vals) {
+    tags.emplace_back(TagKey::Register(kv.first), std::string(kv.second));
+  }
+  *out = TagMap(std::move(tags));
+  return true;
+}
+
+std::string ToGrpcTagsBinHeader(const TagMap& tags) {
+  std::string out;
+  out.push_back(kVersionId);
+  for (const auto& key_val : tags.tags()) {
+    const auto& key = key_val.first;
+    const auto& val = key_val.second;
+    out.push_back(kTagFieldId);
+    AppendVarint(key.name().length(), &out);
+    out.append(key.name());
+    AppendVarint(val.length(), &out);
+    // Encoded value must be UTF-8.
+    out.append(val);
+    if (out.size() > kMaxLen) {
+      break;
+    }
+  }
+  if (out.size() > kMaxLen) {
+    return "";
+  }
+  return out;
+}
+
+}  // namespace propagation
+}  // namespace tags
+}  // namespace opencensus

opencensus/tags/internal/grpc_tags_bin_benchmark.cc

@@ -0,0 +1,54 @@
+// Copyright 2019, OpenCensus Authors
+//
+// 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 "absl/strings/string_view.h"
+#include "benchmark/benchmark.h"
+#include "opencensus/tags/propagation/grpc_tags_bin.h"
+#include "opencensus/tags/tag_key.h"
+#include "opencensus/tags/tag_map.h"
+
+namespace opencensus {
+namespace tags {
+namespace propagation {
+namespace {
+
+void BM_FromGrpcTagsBinHeader(benchmark::State& state) {
+  constexpr char tagsbin[] = {
+      0,                 // Version
+      0,                 // Tag field
+      3, 'k', 'e', 'y',  // k1
+      3, 'v', 'a', 'l',  // v1
+  };
+  const absl::string_view hdr(tagsbin, sizeof(tagsbin));
+  TagMap m({});
+  for (auto _ : state) {
+    FromGrpcTagsBinHeader(hdr, &m);
+  }
+}
+BENCHMARK(BM_FromGrpcTagsBinHeader);
+
+void BM_ToGrpcTagsBinHeader(benchmark::State& state) {
+  TagMap m({{TagKey::Register("key"), "val"}});
+  for (auto _ : state) {
+    ToGrpcTagsBinHeader(m);
+  }
+}
+BENCHMARK(BM_ToGrpcTagsBinHeader);
+
+}  // namespace
+}  // namespace propagation
+}  // namespace tags
+}  // namespace opencensus
+
+BENCHMARK_MAIN();

opencensus/tags/internal/grpc_tags_bin_corpus/kv

@@ -0,0 +1,23 @@
+// Copyright 2019, OpenCensus Authors
+//
+// 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 "absl/strings/string_view.h"
+#include "opencensus/tags/propagation/grpc_tags_bin.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+  absl::string_view input(reinterpret_cast<const char *>(Data), Size);
+  TagMap m({});
+  opencensus::tags::propagation::FromGrpcTagsBinHeader(input, &m);
+  return 0;
+}