The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

193 lines
7.4 KiB

// Copyright 2023 gRPC 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 "test/cpp/interop/xds_stats_watcher.h"
#include <map>
#include "absl/algorithm/container.h"
#include "absl/log/check.h"
#include "absl/strings/ascii.h"
namespace grpc {
namespace testing {
namespace {
void AddRpcMetadata(
LoadBalancerStatsResponse::RpcMetadata* rpc_metadata,
const std::unordered_set<std::string>& included_keys, bool include_all_keys,
const std::multimap<grpc::string_ref, grpc::string_ref>& metadata,
LoadBalancerStatsResponse::MetadataType type) {
for (const auto& key_value : metadata) {
absl::string_view key(key_value.first.data(), key_value.first.length());
if (include_all_keys ||
included_keys.find(absl::AsciiStrToLower(key)) != included_keys.end()) {
auto entry = rpc_metadata->add_metadata();
entry->set_key(key);
entry->set_value(absl::string_view(key_value.second.data(),
key_value.second.length()));
entry->set_type(type);
}
}
}
std::unordered_set<std::string> ToLowerCase(
absl::Span<const std::string> strings) {
std::unordered_set<std::string> result;
for (const auto& str : strings) {
result.emplace(absl::AsciiStrToLower(str));
}
return result;
}
bool HasNonEmptyMetadata(
const std::map<std::string, LoadBalancerStatsResponse::MetadataByPeer>&
metadata_by_peer) {
for (const auto& entry : metadata_by_peer) {
for (const auto& rpc_metadata : entry.second.rpc_metadata()) {
if (rpc_metadata.metadata_size() > 0) {
return true;
}
}
}
return false;
}
} // namespace
XdsStatsWatcher::XdsStatsWatcher(int start_id, int end_id,
absl::Span<const std::string> metadata_keys)
: start_id_(start_id),
end_id_(end_id),
rpcs_needed_(end_id - start_id),
metadata_keys_(ToLowerCase(metadata_keys)),
include_all_metadata_(
absl::c_any_of(metadata_keys, [](absl::string_view key) {
return absl::StripAsciiWhitespace(key) == "*";
})) {}
void XdsStatsWatcher::RpcCompleted(
const AsyncClientCallResult& call, const std::string& peer,
const std::multimap<grpc::string_ref, grpc::string_ref>& initial_metadata,
const std::multimap<grpc::string_ref, grpc::string_ref>&
trailing_metadata) {
// We count RPCs for global watcher or if the request_id falls into the
// watcher's interested range of request ids.
if ((start_id_ == 0 && end_id_ == 0) ||
(start_id_ <= call.saved_request_id && call.saved_request_id < end_id_)) {
{
std::lock_guard<std::mutex> lock(m_);
if (peer.empty()) {
no_remote_peer_++;
++no_remote_peer_by_type_[call.rpc_type];
} else {
// RPC is counted into both per-peer bin and per-method-per-peer bin.
rpcs_by_peer_[peer]++;
rpcs_by_type_[call.rpc_type][peer]++;
auto* rpc_metadata = metadata_by_peer_[peer].add_rpc_metadata();
AddRpcMetadata(rpc_metadata, metadata_keys_, include_all_metadata_,
initial_metadata, LoadBalancerStatsResponse::INITIAL);
AddRpcMetadata(rpc_metadata, metadata_keys_, include_all_metadata_,
trailing_metadata, LoadBalancerStatsResponse::TRAILING);
}
rpcs_needed_--;
// Report accumulated stats.
auto& stats_per_method = *accumulated_stats_.mutable_stats_per_method();
auto& method_stat =
stats_per_method[ClientConfigureRequest_RpcType_Name(call.rpc_type)];
auto& result = *method_stat.mutable_result();
grpc_status_code code =
static_cast<grpc_status_code>(call.status.error_code());
auto& num_rpcs = result[code];
++num_rpcs;
auto rpcs_started = method_stat.rpcs_started();
method_stat.set_rpcs_started(++rpcs_started);
}
cv_.notify_one();
}
}
LoadBalancerStatsResponse XdsStatsWatcher::WaitForRpcStatsResponse(
int timeout_sec) {
LoadBalancerStatsResponse response;
std::unique_lock<std::mutex> lock(m_);
cv_.wait_for(lock, std::chrono::seconds(timeout_sec),
[this] { return rpcs_needed_ == 0; });
response.mutable_rpcs_by_peer()->insert(rpcs_by_peer_.begin(),
rpcs_by_peer_.end());
// Return metadata if at least one RPC had relevant metadata. Note that empty
// entries would be returned for RCPs with no relevant metadata in this case.
if (HasNonEmptyMetadata(metadata_by_peer_)) {
response.mutable_metadatas_by_peer()->insert(metadata_by_peer_.begin(),
metadata_by_peer_.end());
}
auto& response_rpcs_by_method = *response.mutable_rpcs_by_method();
for (const auto& rpc_by_type : rpcs_by_type_) {
std::string method_name;
if (rpc_by_type.first == ClientConfigureRequest::EMPTY_CALL) {
method_name = "EmptyCall";
} else if (rpc_by_type.first == ClientConfigureRequest::UNARY_CALL) {
method_name = "UnaryCall";
} else {
CHECK(0);
}
// TODO(@donnadionne): When the test runner changes to accept EMPTY_CALL
// and UNARY_CALL we will just use the name of the enum instead of the
// method_name variable.
auto& response_rpc_by_method = response_rpcs_by_method[method_name];
auto& response_rpcs_by_peer =
*response_rpc_by_method.mutable_rpcs_by_peer();
for (const auto& rpc_by_peer : rpc_by_type.second) {
auto& response_rpc_by_peer = response_rpcs_by_peer[rpc_by_peer.first];
response_rpc_by_peer = rpc_by_peer.second;
}
}
response.set_num_failures(no_remote_peer_ + rpcs_needed_);
return response;
}
void XdsStatsWatcher::GetCurrentRpcStats(
LoadBalancerAccumulatedStatsResponse* response,
StatsWatchers* stats_watchers) {
std::unique_lock<std::mutex> lock(m_);
response->CopyFrom(accumulated_stats_);
// TODO(someone): delete deprecated stats below when the test is no
// longer using them.
// NOLINTBEGIN(clang-diagnostic-deprecated-declarations)
auto& response_rpcs_started_by_method =
*response->mutable_num_rpcs_started_by_method();
auto& response_rpcs_succeeded_by_method =
*response->mutable_num_rpcs_succeeded_by_method();
auto& response_rpcs_failed_by_method =
*response->mutable_num_rpcs_failed_by_method();
// NOLINTEND(clang-diagnostic-deprecated-declarations)
for (const auto& rpc_by_type : rpcs_by_type_) {
auto total_succeeded = 0;
for (const auto& rpc_by_peer : rpc_by_type.second) {
total_succeeded += rpc_by_peer.second;
}
response_rpcs_succeeded_by_method[ClientConfigureRequest_RpcType_Name(
rpc_by_type.first)] = total_succeeded;
response_rpcs_started_by_method[ClientConfigureRequest_RpcType_Name(
rpc_by_type.first)] =
stats_watchers->global_request_id_by_type[rpc_by_type.first];
response_rpcs_failed_by_method[ClientConfigureRequest_RpcType_Name(
rpc_by_type.first)] = no_remote_peer_by_type_[rpc_by_type.first];
}
}
} // namespace testing
} // namespace grpc