Make the language reported via headers configurable (#6264)

Author: var-const

Firestore/Source/API/FIRFirestore.mm

@@ -96,6 +96,7 @@ @implementation FIRFirestore {
 + (void)initialize {
   if (self == [FIRFirestore class]) {
     SetThrowHandler(ObjcThrowHandler);
+    Firestore::SetClientLanguage("gl-objc/");
   }
 }
 

Firestore/core/src/api/firestore.cc

@@ -31,6 +31,7 @@
 #include "Firestore/core/src/local/leveldb_persistence.h"
 #include "Firestore/core/src/model/document_key.h"
 #include "Firestore/core/src/model/resource_path.h"
+#include "Firestore/core/src/remote/grpc_connection.h"
 #include "Firestore/core/src/util/async_queue.h"
 #include "Firestore/core/src/util/executor.h"
 #include "Firestore/core/src/util/hard_assert.h"
@@ -49,6 +50,7 @@ using core::Transaction;
 using local::LevelDbPersistence;
 using model::DocumentKey;
 using model::ResourcePath;
+using remote::GrpcConnection;
 using util::AsyncQueue;
 using util::Empty;
 using util::Executor;
@@ -191,6 +193,10 @@ void Firestore::DisableNetwork(util::StatusCallback callback) {
   client_->DisableNetwork(std::move(callback));
 }
 
+void Firestore::SetClientLanguage(std::string language_token) {
+  GrpcConnection::SetClientLanguage(std::move(language_token));
+}
+
 std::unique_ptr<ListenerRegistration> Firestore::AddSnapshotsInSyncListener(
     std::unique_ptr<core::EventListener<Empty>> listener) {
   EnsureClientConfigured();

Firestore/core/src/api/firestore.h

@@ -95,6 +95,12 @@ class Firestore : public std::enable_shared_from_this<Firestore> {
   void EnableNetwork(util::StatusCallback callback);
   void DisableNetwork(util::StatusCallback callback);
 
+  /**
+   * Sets the language of the public API in the format of
+   * "gl-<language>/<version>" where version might be blank, e.g. `gl-objc/`.
+   */
+  static void SetClientLanguage(std::string language_token);
+
  private:
   void EnsureClientConfigured();
   core::DatabaseInfo MakeDatabaseInfo() const;

Firestore/core/src/remote/grpc_connection.cc

@@ -35,6 +35,7 @@
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "grpcpp/create_channel.h"
+#include "grpcpp/grpcpp.h"
 
 namespace firebase {
 namespace firestore {
@@ -119,8 +120,59 @@ class HostConfigMap {
 };
 
 HostConfigMap& Config() {
-  static HostConfigMap config_by_host_;
-  return config_by_host_;
+  static HostConfigMap config_by_host;
+  return config_by_host;
+}
+
+std::string GetCppLanguageToken() {
+  const char* cpp_version = [] {
+    switch (__cplusplus) {
+      case 199711L:
+        return "1998";
+      case 201103L:
+        return "2011";
+      case 201402L:
+        return "2014";
+      case 201703L:
+        return "2017";
+      case 202002L:
+        return "2020";
+      default:
+        return "";
+    }
+  }();
+
+  return StringFormat("gl-cpp/%s", cpp_version);
+}
+
+class ClientLanguageToken {
+  using Guard = std::lock_guard<std::mutex>;
+
+ public:
+  void Set(std::string value) {
+    Guard guard(mutex_);
+    value_ = std::move(value);
+  }
+
+  const std::string& Get() const {
+    Guard guard(mutex_);
+    return value_;
+  }
+
+ private:
+  std::string value_ = GetCppLanguageToken();
+  mutable std::mutex mutex_;
+};
+
+ClientLanguageToken& LanguageToken() {
+  static ClientLanguageToken token;
+  return token;
+}
+
+void AddCloudApiHeader(grpc::ClientContext& context) {
+  auto api_tokens = StringFormat("%s fire/%s grpc/%s", LanguageToken().Get(),
+                                 kFirestoreVersionString, grpc::Version());
+  context.AddMetadata(kXGoogAPIClientHeader, api_tokens);
 }
 
 #if __APPLE__
@@ -173,16 +225,7 @@ std::unique_ptr<grpc::ClientContext> GrpcConnection::CreateContext(
     context->AddMetadata(kAuthorizationHeader, absl::StrCat("Bearer ", token));
   }
 
-  // TODO(dimond): This should ideally also include the gRPC version, however,
-  // gRPC defines the version as a macro, so it would be hardcoded based on
-  // version we have at compile time of the Firestore library, rather than the
-  // version available at runtime/at compile time by the user of the library.
-  //
-  // TODO(varconst): this should be configurable (e.g., "gl-cpp" or similar for
-  // C++ SDK, etc.).
-  context->AddMetadata(
-      kXGoogAPIClientHeader,
-      StringFormat("gl-objc/ fire/%s grpc/", kFirestoreVersionString));
+  AddCloudApiHeader(*context);
 
   // This header is used to improve routing and project isolation by the
   // backend.
@@ -307,17 +350,20 @@ void GrpcConnection::Unregister(GrpcCall* call) {
   active_calls_.erase(found);
 }
 
-/*static*/ void GrpcConnection::UseTestCertificate(
-    const std::string& host,
-    const Path& certificate_path,
-    const std::string& target_name) {
-  Config().UseTestCertificate(host, certificate_path, target_name);
+void GrpcConnection::SetClientLanguage(std::string language_token) {
+  LanguageToken().Set(std::move(language_token));
 }
 
-/*static*/ void GrpcConnection::UseInsecureChannel(const std::string& host) {
+void GrpcConnection::UseInsecureChannel(const std::string& host) {
   Config().UseInsecureChannel(host);
 }
 
+void GrpcConnection::UseTestCertificate(const std::string& host,
+                                        const Path& certificate_path,
+                                        const std::string& target_name) {
+  Config().UseTestCertificate(host, certificate_path, target_name);
+}
+
 }  // namespace remote
 }  // namespace firestore
 }  // namespace firebase

Firestore/core/src/remote/grpc_connection.h

@@ -85,6 +85,8 @@ class GrpcConnection {
   void Register(GrpcCall* call);
   void Unregister(GrpcCall* call);
 
+  static void SetClientLanguage(std::string language_token);
+
   /**
    * Don't use SSL, send all traffic unencrypted. Call before creating any
    * streams or calls.

scripts/style.sh

@@ -53,7 +53,7 @@ case "$version" in
   *)
     echo "Please upgrade to clang-format version 10."
     echo "If it's installed via homebrew you can run:"
-    echo "brew install clang-format"
+    echo "brew upgrade clang-format"
     exit 1
     ;;
 esac