feat(bigtable): add logging for result set reader (#15699)

* feat(bigtable): add logging for result set reader

* chore: run linter

Author: diegomarquezp

google/cloud/bigtable/CMakeLists.txt

@@ -201,6 +201,8 @@ add_library(
     internal/legacy_row_reader.h
     internal/logging_data_client.cc
     internal/logging_data_client.h
+    internal/logging_result_set_reader.cc
+    internal/logging_result_set_reader.h
     internal/metrics.cc
     internal/metrics.h
     internal/mutate_rows_limiter.cc
@@ -484,6 +486,7 @@ if (BUILD_TESTING)
         internal/legacy_bulk_mutator_test.cc
         internal/legacy_row_reader_test.cc
         internal/logging_data_client_test.cc
+        internal/logging_result_set_reader_test.cc
         internal/metrics_test.cc
         internal/mutate_rows_limiter_test.cc
         internal/operation_context_factory_test.cc

google/cloud/bigtable/bigtable_client_unit_tests.bzl

@@ -62,6 +62,7 @@ bigtable_client_unit_tests = [
     "internal/legacy_bulk_mutator_test.cc",
     "internal/legacy_row_reader_test.cc",
     "internal/logging_data_client_test.cc",
+    "internal/logging_result_set_reader_test.cc",
     "internal/metrics_test.cc",
     "internal/mutate_rows_limiter_test.cc",
     "internal/operation_context_factory_test.cc",

google/cloud/bigtable/google_cloud_cpp_bigtable.bzl

@@ -99,6 +99,7 @@ google_cloud_cpp_bigtable_hdrs = [
     "internal/legacy_async_row_sampler.h",
     "internal/legacy_row_reader.h",
     "internal/logging_data_client.h",
+    "internal/logging_result_set_reader.h",
     "internal/metrics.h",
     "internal/mutate_rows_limiter.h",
     "internal/operation_context.h",
@@ -217,6 +218,7 @@ google_cloud_cpp_bigtable_srcs = [
     "internal/legacy_async_row_sampler.cc",
     "internal/legacy_row_reader.cc",
     "internal/logging_data_client.cc",
+    "internal/logging_result_set_reader.cc",
     "internal/metrics.cc",
     "internal/mutate_rows_limiter.cc",
     "internal/operation_context.cc",

google/cloud/bigtable/internal/logging_result_set_reader.cc

@@ -0,0 +1,52 @@
+// Copyright 2025 Google LLC
+//
+// 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
+//
+//     https://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 "google/cloud/bigtable/internal/logging_result_set_reader.h"
+#include "google/cloud/internal/debug_string.h"
+#include "google/cloud/log.h"
+
+namespace google {
+namespace cloud {
+namespace bigtable_internal {
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
+
+using ::google::cloud::internal::DebugString;
+
+void LoggingResultSetReader::TryCancel() { impl_->TryCancel(); }
+
+bool LoggingResultSetReader::Read(
+    absl::optional<std::string> const& resume_token,
+    UnownedPartialResultSet& result) {
+  if (resume_token) {
+    GCP_LOG(DEBUG) << __func__ << "() << resume_token=\""
+                   << DebugString(*resume_token, tracing_options_) << "\"";
+  } else {
+    GCP_LOG(DEBUG) << __func__ << "() << (unresumable)";
+  }
+  bool success = impl_->Read(resume_token, result);
+  if (!success) {
+    GCP_LOG(DEBUG) << __func__ << "() >> (failed)";
+  } else {
+    GCP_LOG(DEBUG) << __func__ << "() >> resumption="
+                   << (result.resumption ? "true" : "false");
+  }
+  return success;
+}
+
+Status LoggingResultSetReader::Finish() { return impl_->Finish(); }
+
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
+}  // namespace bigtable_internal
+}  // namespace cloud
+}  // namespace google

google/cloud/bigtable/internal/logging_result_set_reader.h

@@ -0,0 +1,56 @@
+// Copyright 2025 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_INTERNAL_LOGGING_RESULT_SET_READER_H
+#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_INTERNAL_LOGGING_RESULT_SET_READER_H
+
+#include "google/cloud/bigtable/internal/partial_result_set_reader.h"
+#include "google/cloud/bigtable/version.h"
+#include "google/cloud/tracing_options.h"
+#include "absl/types/optional.h"
+#include <memory>
+
+namespace google {
+namespace cloud {
+namespace bigtable_internal {
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
+
+/**
+ * A `PartialResultSetReader` decorator that logs the `Read()` `resume_token`
+ * parameter and the `PartialResultSet::resumption` return value. This is an
+ * extension to the standard `BigtableLogging` request/response logging.
+ */
+class LoggingResultSetReader : public PartialResultSetReader {
+ public:
+  LoggingResultSetReader(std::unique_ptr<PartialResultSetReader> impl,
+                         TracingOptions tracing_options)
+      : impl_(std::move(impl)), tracing_options_(std::move(tracing_options)) {}
+  ~LoggingResultSetReader() override = default;
+
+  void TryCancel() override;
+  bool Read(absl::optional<std::string> const& resume_token,
+            UnownedPartialResultSet& result) override;
+  Status Finish() override;
+
+ private:
+  std::unique_ptr<PartialResultSetReader> impl_;
+  TracingOptions tracing_options_;
+};
+
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
+}  // namespace bigtable_internal
+}  // namespace cloud
+}  // namespace google
+
+#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_INTERNAL_LOGGING_RESULT_SET_READER_H

google/cloud/bigtable/internal/logging_result_set_reader_test.cc

@@ -0,0 +1,98 @@
+// Copyright 2025 Google LLC
+//
+// 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
+//
+//     https://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 "google/cloud/bigtable/internal/logging_result_set_reader.h"
+#include "google/cloud/bigtable/testing/mock_partial_result_set_reader.h"
+#include "google/cloud/log.h"
+#include "google/cloud/testing_util/scoped_log.h"
+#include "google/cloud/testing_util/status_matchers.h"
+#include "google/cloud/tracing_options.h"
+#include <gmock/gmock.h>
+
+namespace google {
+namespace cloud {
+namespace bigtable_internal {
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
+namespace {
+
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::Contains;
+using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::StartsWith;
+
+class LoggingResultSetReaderTest : public ::testing::Test {
+ protected:
+  testing_util::ScopedLog log_;
+};
+
+TEST_F(LoggingResultSetReaderTest, TryCancel) {
+  auto mock = std::make_unique<bigtable_testing::MockPartialResultSetReader>();
+  EXPECT_CALL(*mock, TryCancel()).Times(1);
+  LoggingResultSetReader reader(std::move(mock), TracingOptions{});
+  reader.TryCancel();
+
+  EXPECT_THAT(log_.ExtractLines(), IsEmpty());
+}
+
+TEST_F(LoggingResultSetReaderTest, Read) {
+  auto mock = std::make_unique<bigtable_testing::MockPartialResultSetReader>();
+  EXPECT_CALL(*mock, Read(_, _))
+      .WillOnce([](absl::optional<std::string> const&,
+                   UnownedPartialResultSet& result) {
+        result.resumption = false;
+        result.result.set_resume_token("test-token");
+        return true;
+      })
+      .WillOnce([] { return false; });
+  LoggingResultSetReader reader(std::move(mock), TracingOptions{});
+  google::bigtable::v2::PartialResultSet partial_result_set;
+  auto result =
+      UnownedPartialResultSet::FromPartialResultSet(partial_result_set);
+  ASSERT_TRUE(reader.Read("", result));
+  EXPECT_EQ("test-token", result.result.resume_token());
+
+  auto log_lines = log_.ExtractLines();
+  EXPECT_THAT(log_lines, AllOf(Contains(StartsWith("Read()"))));
+  EXPECT_THAT(log_lines, Contains(HasSubstr("resume_token=\"\"")));
+  EXPECT_THAT(log_lines, Contains(HasSubstr("resumption=false")));
+
+  ASSERT_FALSE(reader.Read("test-token", result));
+
+  log_lines = log_.ExtractLines();
+  EXPECT_THAT(log_lines, AllOf(Contains(StartsWith("Read()"))));
+  EXPECT_THAT(log_lines, Contains(HasSubstr("resume_token=\"test-token\"")));
+  EXPECT_THAT(log_lines, Contains(HasSubstr("(failed)")));
+}
+
+TEST_F(LoggingResultSetReaderTest, Finish) {
+  Status const expected_status = Status(StatusCode::kOutOfRange, "weird");
+  auto mock = std::make_unique<bigtable_testing::MockPartialResultSetReader>();
+  EXPECT_CALL(*mock, Finish()).WillOnce([expected_status] {
+    return expected_status;  // NOLINT(performance-no-automatic-move)
+  });
+  LoggingResultSetReader reader(std::move(mock), TracingOptions{});
+  auto status = reader.Finish();
+  EXPECT_EQ(expected_status, status);
+
+  auto log_lines = log_.ExtractLines();
+  EXPECT_THAT(log_lines, IsEmpty());
+}
+
+}  // namespace
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
+}  // namespace bigtable_internal
+}  // namespace cloud
+}  // namespace google