Desktop implementation of platform logging v2 (#1089)

Implement Heartbeat controller and storage. Integrate with firestore and auth.

Author: AlmostMatt

app/CMakeLists.txt

@@ -65,7 +65,7 @@ set(FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS
 set(FLATC_ARGS "${FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS}")
 build_flatbuffers("${CMAKE_CURRENT_LIST_DIR}/google_services.fbs"
                   ""
-                  "app_generated_includes"
+                  "app_generated_google_services_includes"
                   "${FIREBASE_FLATBUFFERS_DEPENDENCIES}"
                   "${FIREBASE_GEN_FILE_DIR}/app"
                   ""
@@ -169,12 +169,39 @@ if (PLATFORM STREQUAL TVOS OR PLATFORM STREQUAL SIMULATOR_TVOS)
     src/invites/ios/invites_ios_startup.mm)
 endif()
 
+
+# Flatbuffer schemas used by the desktop implementation.
+set(desktop_flatbuffers_schema_dir
+    "${CMAKE_CURRENT_LIST_DIR}/src/heartbeat/schemas")
+set(desktop_flatbuffers_schemas
+    "${desktop_flatbuffers_schema_dir}/logged_heartbeats.fbs")
+set(FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS
+    "--no-union-value-namespacing"
+    "--gen-generated"
+    "--gen-object-api"
+    "--cpp-ptr-type" "flatbuffers::unique_ptr")
+# Because of a bug in the version of Flatbuffers we are pinned to,
+# additional flags need to be set.
+# also see if app_generated_includes will conflict
+set(FLATC_ARGS "${FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS}")
+build_flatbuffers("${desktop_flatbuffers_schemas}"
+                  "${CMAKE_CURRENT_LIST_DIR}"
+                  "app_generated_includes"
+                  "${FIREBASE_FLATBUFFERS_DEPENDENCIES}"
+                  "${FIREBASE_GEN_FILE_DIR}/app"
+                  ""
+                  "")
+
 set(app_desktop_SRCS
     src/app_desktop.cc
-    src/heartbeat_date_storage_desktop.cc
-    src/heartbeat_info_desktop.cc
     src/invites/stub/invites_receiver_internal_stub.cc
-    src/variant_util.cc)
+    src/variant_util.cc
+    src/heartbeat/date_provider.cc
+    src/heartbeat/heartbeat_storage_desktop.cc
+    src/heartbeat/heartbeat_controller_desktop.cc
+    rest/gzipheader.cc
+    rest/zlibwrapper.cc
+    ${FIREBASE_GEN_FILE_DIR}/app/logged_heartbeats_generated.h)
 if(ANDROID)
   set(app_platform_SRCS
       "${app_android_SRCS}")
@@ -244,8 +271,6 @@ set(utility_common_HDRS
     src/future_manager.h
     src/intrusive_list.h
     src/log.h
-    src/heartbeat_date_storage_desktop.h
-    src/heartbeat_info_desktop.h
     src/optional.h
     src/path.h
     src/pthread_condvar.h
@@ -347,6 +372,14 @@ target_include_directories(firebase_app
     ${FLATBUFFERS_SOURCE_DIR}/include
     ${LIBSECRET_INCLUDE_DIRS}
 )
+
+if (DESKTOP)
+  target_include_directories(firebase_app
+    PRIVATE
+      ${ZLIB_SOURCE_DIR}/..
+      ${ZLIB_BINARY_DIR})
+endif()
+
 target_compile_definitions(firebase_app
   PRIVATE
     -DINTERNAL_EXPERIMENTAL=1
@@ -390,6 +423,9 @@ elseif(IOS)
       FirebaseDynamicLinks
       FirebaseInstanceID
   )
+else()
+  target_link_libraries(firebase_app
+    PRIVATE zlibstatic)
 endif()
 
 if (NOT ANDROID AND NOT IOS)

app/src/app_common.cc

@@ -169,6 +169,7 @@ const char* kBuildSource = "custom_built";
 // clang-format=on
 
 const char* kApiClientHeader = "x-firebase-client";
+const char* kXFirebaseGmpIdHeader = "X-Firebase-GMPID";
 
 SystemLogger g_system_logger;  // NOLINT
 

app/src/app_common.h

@@ -43,8 +43,9 @@ extern const char* kCppRuntimeOrStl;
 extern const char* kCpuArchitecture;
 extern const char* kBuildSource;
 
-// Extended API client header for Google user agent strings.
+// Request headers used by platform monitoring.
 extern const char* kApiClientHeader;
+extern const char* kXFirebaseGmpIdHeader;
 
 // Add an app to the set of apps.
 App* AddApp(App* app, std::map<std::string, InitResult>* results);

app/src/app_desktop.cc

@@ -14,12 +14,17 @@
  * limitations under the License.
  */
 
+#include "app/src/app_desktop.h"
+
 #include <string.h>
 
 #include <fstream>
+#include <memory>
+#include <string>
 
 #include "app/src/app_common.h"
 #include "app/src/function_registry.h"
+#include "app/src/heartbeat/heartbeat_controller_desktop.h"
 #include "app/src/include/firebase/app.h"
 #include "app/src/include/firebase/internal/common.h"
 #include "app/src/include/firebase/version.h"
@@ -29,24 +34,6 @@
 namespace firebase {
 DEFINE_FIREBASE_VERSION_STRING(Firebase);
 
-namespace internal {
-
-class AppInternal {
- public:
-  // A registry that modules can use to expose functions to each other, without
-  // requiring a linkage dependency.
-  // todo - make all the implementations use something like this, for internal
-  // or implementation-specific code.  b/70229654
-  FunctionRegistry function_registry;
-};
-
-// When Create() is invoked without arguments, it checks for a file named
-// google-services-desktop.json, to load options from.  This specifies the
-// path to search.
-static std::string g_default_config_path;  // NOLINT
-
-}  // namespace internal
-
 namespace {
 
 // Size is arbitrary, just making sure that there is a sane limit.
@@ -150,6 +137,15 @@ App* App::Create(const AppOptions& options, const char* name) {  // NOLINT
     app->name_ = name;
     app->options_ = options_with_defaults;
     app = app_common::AddApp(app, &app->init_results_);
+    app->internal_->heartbeat_controller_ =
+        std::make_shared<heartbeat::HeartbeatController>(
+            name, *app_common::FindAppLoggerByName(name),
+            app->internal_->date_provider_);
+#ifndef SWIG
+    // Log a heartbeat after creating an App. In the Unity SDK this will happen
+    // at a later time, after additional user agents have been registered.
+    app->internal_->heartbeat_controller_->LogHeartbeat();
+#endif  // SWIG
   }
   return app;
 }
@@ -166,7 +162,7 @@ App* App::GetInstance(const char* name) {  // NOLINT
 internal::FunctionRegistry* App::function_registry() {
   return &internal_->function_registry;
 }
-#endif
+#endif  // INTERNAL_EXPERIMENTAL
 
 void App::RegisterLibrary(const char* library, const char* version) {
   app_common::RegisterLibrary(library, version);
@@ -191,6 +187,21 @@ void App::SetDefaultConfigPath(const char* path) {
   }
 }
 
+void App::LogHeartbeat() const {
+  if (internal_ != nullptr && internal_->heartbeat_controller_) {
+    internal_->heartbeat_controller_->LogHeartbeat();
+  }
+}
+
+std::shared_ptr<heartbeat::HeartbeatController> App::GetHeartbeatController()
+    const {
+  if (internal_ != nullptr) {
+    return internal_->heartbeat_controller_;
+  } else {
+    return std::shared_ptr<heartbeat::HeartbeatController>();
+  }
+}
+
 // Desktop support is for developer workflow only, so automatic data collection
 // is always enabled.
 void App::SetDataCollectionDefaultEnabled(bool /* enabled */) {}

app/src/app_desktop.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2022 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
+ *
+ *      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 <memory>
+
+#include "app/src/app_common.h"
+#include "app/src/function_registry.h"
+#include "app/src/heartbeat/heartbeat_controller_desktop.h"
+#include "app/src/include/firebase/app.h"
+#include "app/src/include/firebase/internal/common.h"
+#include "app/src/include/firebase/version.h"
+
+namespace firebase {
+// DEFINE_FIREBASE_VERSION_STRING(Firebase);
+
+namespace internal {
+
+class AppInternal {
+ public:
+  // A registry that modules can use to expose functions to each other, without
+  // requiring a linkage dependency.
+  // todo - make all the implementations use something like this, for internal
+  // or implementation-specific code.  b/70229654
+  FunctionRegistry function_registry;
+
+  // HeartbeatController provides methods to log heartbeats and fetch payloads.
+  std::shared_ptr<heartbeat::HeartbeatController> heartbeat_controller_;
+
+  // Has a method to get the current date. Used by heartbeat_controller.
+  firebase::heartbeat::DateProviderImpl date_provider_;
+};
+
+// When Create() is invoked without arguments, it checks for a file named
+// google-services-desktop.json, to load options from.  This specifies the
+// path to search.
+static std::string g_default_config_path;  // NOLINT
+
+}  // namespace internal
+}  // namespace firebase

app/src/heartbeat/date_provider.cc

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 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
+ *
+ *      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 "app/src/heartbeat/date_provider.h"
+
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+namespace firebase {
+namespace heartbeat {
+
+std::string DateProviderImpl::GetDate() const {
+  std::time_t t = std::time(nullptr);
+  // Use UTC time so that local time zone changes are ignored.
+  std::tm* tm = std::gmtime(&t);
+  std::ostringstream ss;
+  // Format the date as yyyy-mm-dd, independent of locale.
+  ss << std::put_time(tm, "%Y-%m-%d");
+  return ss.str();
+}
+
+}  // namespace heartbeat
+}  // namespace firebase

app/src/heartbeat/date_provider.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2022 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
+ *
+ *      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.
+ */
+
+#ifndef FIREBASE_APP_SRC_HEARTBEAT_DATE_PROVIDER_H_
+#define FIREBASE_APP_SRC_HEARTBEAT_DATE_PROVIDER_H_
+
+#include <string>
+
+namespace firebase {
+namespace heartbeat {
+
+class DateProvider {
+ public:
+  virtual std::string GetDate() const = 0;
+};
+
+class DateProviderImpl : public DateProvider {
+ public:
+  std::string GetDate() const override;
+};
+
+}  // namespace heartbeat
+}  // namespace firebase
+
+#endif  // FIREBASE_APP_SRC_HEARTBEAT_DATE_PROVIDER_H_