impl(bigtable): add directpath metric (#16370)

Author: scotthart

google/cloud/bigtable/internal/client_schema_metrics.cc

@@ -22,8 +22,6 @@
 #include <opentelemetry/semconv/incubating/cloud_attributes.h>
 #include <opentelemetry/semconv/incubating/faas_attributes.h>
 #include <opentelemetry/semconv/incubating/host_attributes.h>
-#include <algorithm>
-#include <map>
 #include <set>
 #include <string_view>
 
@@ -63,33 +61,54 @@ std::string_view IsStreamingAsString(RpcType type) {
   }
   return "false";
 }
+
+LabelMap BaseLabels(ClientResourceLabels const& r) {
+  return {{"project_id", r.project_id},   {"instance", r.instance},
+          {"app_profile", r.app_profile}, {"client_name", r.client_name},
+          {"client_uid", r.client_uid},   {"client_project", r.client_project},
+          {"location", r.location},       {"cloud_platform", r.cloud_platform},
+          {"host_id", r.host_id},         {"hostname", r.hostname}};
+}
 }  // namespace
 
 LabelMap IntoLabelMap(ClientResourceLabels const& r,
                       ClientOutstandingRpcLabels const& d,
                       std::set<std::string> const& filtered_data_labels) {
-  LabelMap labels = {
-      {"project_id", r.project_id},   {"instance", r.instance},
-      {"app_profile", r.app_profile}, {"client_name", r.client_name},
-      {"client_uid", r.client_uid},   {"client_project", r.client_project},
-      {"location", r.location},       {"cloud_platform", r.cloud_platform},
-      {"host_id", r.host_id},         {"hostname", r.hostname}};
-
-  struct {
-    std::string key;
-    std::string value;
-  } data[] = {
-      {"transport_type", std::string(ToString(d.transport_type))},
-      {"channel_pool_lb_policy",
-       std::string(ToString(d.channel_pool_lb_policy))},
-      {"streaming", std::string(IsStreamingAsString(d.streaming))},
+  LabelMap labels = BaseLabels(r);
+
+  auto emplace_if_not_filtered = [&](std::string_view key,
+                                     std::string_view value) {
+    if (filtered_data_labels.empty() ||
+        filtered_data_labels.find(std::string(key)) ==
+            filtered_data_labels.end()) {
+      labels.emplace(key, value);
+    }
   };
 
-  for (auto& item : data) {
-    if (filtered_data_labels.find(item.key) == filtered_data_labels.end()) {
-      labels.emplace(std::move(item.key), std::move(item.value));
+  emplace_if_not_filtered("transport_type", ToString(d.transport_type));
+  emplace_if_not_filtered("channel_pool_lb_policy",
+                          ToString(d.channel_pool_lb_policy));
+  emplace_if_not_filtered("streaming", IsStreamingAsString(d.streaming));
+
+  return labels;
+}
+
+LabelMap IntoLabelMap(ClientResourceLabels const& r,
+                      DirectAccessCompatibilityLabels const& d,
+                      std::set<std::string> const& filtered_data_labels) {
+  LabelMap labels = BaseLabels(r);
+
+  auto emplace_if_not_filtered = [&](std::string_view key,
+                                     std::string_view value) {
+    if (filtered_data_labels.empty() ||
+        filtered_data_labels.find(std::string(key)) ==
+            filtered_data_labels.end()) {
+      labels.emplace(key, value);
     }
-  }
+  };
+
+  emplace_if_not_filtered("ip_preference", d.ip_preference);
+  emplace_if_not_filtered("reason", d.reason);
 
   return labels;
 }
@@ -109,10 +128,8 @@ ClientResourceLabels MakeClientResourceLabels(
     return opentelemetry::nostd::get<std::string>(l->second);
   };
 
-  if (project_id.empty() &&
-      options.has<bigtable_internal::InstanceChannelAffinityOption>()) {
-    auto const& instances =
-        options.get<bigtable_internal::InstanceChannelAffinityOption>();
+  if (project_id.empty() && options.has<InstanceChannelAffinityOption>()) {
+    auto const& instances = options.get<InstanceChannelAffinityOption>();
     if (!instances.empty()) {
       project_id = instances[0].project_id();
     }
@@ -121,6 +138,17 @@ ClientResourceLabels MakeClientResourceLabels(
     project_id = by_name(sc::cloud::kCloudAccountId);
   }
 
+  if (instance.empty() && options.has<InstanceChannelAffinityOption>()) {
+    auto const& instances = options.get<InstanceChannelAffinityOption>();
+    if (!instances.empty()) {
+      instance = instances[0].instance_id();
+    }
+  }
+
+  if (app_profile.empty() && options.has<bigtable::AppProfileIdOption>()) {
+    app_profile = options.get<bigtable::AppProfileIdOption>();
+  }
+
   std::string client_project = by_name(sc::cloud::kCloudAccountId);
   if (client_project.empty()) {
     client_project = project_id;
@@ -166,7 +194,7 @@ void OutstandingRpcs::StubSelection(
   ClientOutstandingRpcLabels data_labels{p.transport_type,
                                          p.channel_pool_lb_policy, p.streaming};
   outstanding_rpcs_->Record(static_cast<double>(p.outstanding_rpcs),
-                            IntoLabelMap(resource_labels_, data_labels),
+                            IntoLabelMap(resource_labels_, data_labels, {}),
                             context);
 }
 
@@ -177,6 +205,48 @@ std::unique_ptr<ClientSchemaMetric> OutstandingRpcs::clone(
   return m;
 }
 
+DirectAccessCompatibility::DirectAccessCompatibility(
+    std::string const& instrumentation_scope,
+    opentelemetry::nostd::shared_ptr<
+        opentelemetry::metrics::MeterProvider> const& provider)
+    : gauge_(
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+          provider
+              ->GetMeter(instrumentation_scope,
+                         kMeterInstrumentationScopeVersion)
+              ->CreateInt64Gauge(
+                  "direct_access/compatible",
+                  "Compatibility check result for Bigtable DirectPath.", "1")
+#else
+          provider
+              ->GetMeter(instrumentation_scope,
+                         kMeterInstrumentationScopeVersion)
+              ->CreateDoubleHistogram(
+                  "direct_access/compatible",
+                  "Compatibility check result for Bigtable DirectPath.", "1")
+#endif
+      ) {
+}
+
+void DirectAccessCompatibility::Record(
+    opentelemetry::context::Context const& context, std::int64_t value,
+    DirectAccessCompatibilityLabels const& data_labels) {
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+  gauge_->Record(value, IntoLabelMap(resource_labels_, data_labels, {}),
+                 context);
+#else
+  gauge_->Record(static_cast<double>(value),
+                 IntoLabelMap(resource_labels_, data_labels, {}), context);
+#endif
+}
+
+std::unique_ptr<ClientSchemaMetric> DirectAccessCompatibility::clone(
+    ClientResourceLabels const& resource_labels) const {
+  auto m = std::make_unique<DirectAccessCompatibility>(*this);
+  m->resource_labels_ = resource_labels;
+  return m;
+}
+
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace bigtable_internal
 }  // namespace cloud

google/cloud/bigtable/internal/client_schema_metrics.h

@@ -54,7 +54,16 @@ struct ClientOutstandingRpcLabels {
 using LabelMap = std::unordered_map<std::string, std::string>;
 LabelMap IntoLabelMap(ClientResourceLabels const& r,
                       ClientOutstandingRpcLabels const& d,
-                      std::set<std::string> const& filtered_data_labels = {});
+                      std::set<std::string> const& filtered_data_labels);
+
+struct DirectAccessCompatibilityLabels {
+  std::string ip_preference;
+  std::string reason;
+};
+
+LabelMap IntoLabelMap(ClientResourceLabels const& r,
+                      DirectAccessCompatibilityLabels const& d,
+                      std::set<std::string> const& filtered_data_labels);
 
 ClientResourceLabels MakeClientResourceLabels(
     std::string project_id, std::string instance, std::string app_profile,
@@ -84,6 +93,31 @@ class OutstandingRpcs : public ClientSchemaMetric {
       outstanding_rpcs_;
 };
 
+class DirectAccessCompatibility : public ClientSchemaMetric {
+ public:
+  DirectAccessCompatibility(
+      std::string const& instrumentation_scope,
+      opentelemetry::nostd::shared_ptr<
+          opentelemetry::metrics::MeterProvider> const& provider);
+
+  void Record(opentelemetry::context::Context const& context,
+              std::int64_t value,
+              DirectAccessCompatibilityLabels const& data_labels);
+
+  std::unique_ptr<ClientSchemaMetric> clone(
+      ClientResourceLabels const& resource_labels) const override;
+
+ private:
+  ClientResourceLabels resource_labels_;
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+  opentelemetry::nostd::shared_ptr<opentelemetry::metrics::Gauge<std::int64_t>>
+      gauge_;
+#else
+  opentelemetry::nostd::shared_ptr<opentelemetry::metrics::Histogram<double>>
+      gauge_;
+#endif
+};
+
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace bigtable_internal
 }  // namespace cloud