CDRIVER-5638 Record both FaaS and container metadata when both are present

src/libmongoc/src/mongoc/mongoc-handshake-private.h

@@ -113,6 +113,9 @@ typedef struct _mongoc_handshake_t {
    char *compiler_info;
    char *flags;
 
+   bool docker;
+   bool kubernetes;
+
    mongoc_handshake_env_t env;
    optional_int32 env_timeout_sec;
    optional_int32 env_memory_mb;

src/libmongoc/src/mongoc/mongoc-handshake.c

@@ -18,6 +18,7 @@
 
 #ifdef _POSIX_VERSION
 #include <sys/utsname.h>
+#include <unistd.h>
 #endif
 
 #ifdef _WIN32
@@ -356,39 +357,33 @@ _get_system_info (mongoc_handshake_t *handshake)
    handshake->os_architecture = _get_os_architecture ();
 }
 
-static void
-_free_system_info (mongoc_handshake_t *handshake)
-{
-   bson_free (handshake->os_type);
-   bson_free (handshake->os_name);
-   bson_free (handshake->os_version);
-   bson_free (handshake->os_architecture);
-}
-
 static void
 _get_driver_info (mongoc_handshake_t *handshake)
 {
    handshake->driver_name = bson_strndup ("mongoc", HANDSHAKE_DRIVER_NAME_MAX);
    handshake->driver_version = bson_strndup (MONGOC_VERSION_S, HANDSHAKE_DRIVER_VERSION_MAX);
 }
 
-static void
-_free_driver_info (mongoc_handshake_t *handshake)
-{
-   bson_free (handshake->driver_name);
-   bson_free (handshake->driver_version);
-}
-
 static void
 _set_platform_string (mongoc_handshake_t *handshake)
 {
    handshake->platform = bson_strdup ("");
 }
 
 static void
-_free_env_info (mongoc_handshake_t *handshake)
+_get_container_info (mongoc_handshake_t *handshake)
 {
-   bson_free (handshake->env_region);
+   char *kubernetes_env = _mongoc_getenv ("KUBERNETES_SERVICE_HOST");
+   handshake->kubernetes = kubernetes_env;
+
+   handshake->docker = false;
+#ifdef _WIN32
+   handshake->docker = (_access_s ("C:\\.dockerenv", 0) == 0);
+#else
+   handshake->docker = (access ("/.dockerenv", F_OK) == 0);
+#endif
+
+   bson_free (kubernetes_env);
 }
 
 static void
@@ -514,21 +509,14 @@ _set_flags (mongoc_handshake_t *handshake)
    handshake->flags = mcommon_string_from_append_destroy_with_steal (&append);
 }
 
-static void
-_free_platform_string (mongoc_handshake_t *handshake)
-{
-   bson_free (handshake->platform);
-   bson_free (handshake->compiler_info);
-   bson_free (handshake->flags);
-}
-
 void
 _mongoc_handshake_init (void)
 {
    _get_system_info (_mongoc_handshake_get ());
    _get_driver_info (_mongoc_handshake_get ());
    _set_platform_string (_mongoc_handshake_get ());
    _get_env_info (_mongoc_handshake_get ());
+   _get_container_info (_mongoc_handshake_get ());
    _set_compiler_info (_mongoc_handshake_get ());
    _set_flags (_mongoc_handshake_get ());
 
@@ -540,10 +528,16 @@ void
 _mongoc_handshake_cleanup (void)
 {
    mongoc_handshake_t *h = _mongoc_handshake_get ();
-   _free_system_info (h);
-   _free_driver_info (h);
-   _free_platform_string (h);
-   _free_env_info (h);
+   bson_free (h->os_type);
+   bson_free (h->os_name);
+   bson_free (h->os_version);
+   bson_free (h->os_architecture);
+   bson_free (h->driver_name);
+   bson_free (h->driver_version);
+   bson_free (h->platform);
+   bson_free (h->compiler_info);
+   bson_free (h->flags);
+   bson_free (h->env_region);
    *h = (mongoc_handshake_t) {0};
 
    bson_mutex_destroy (&gHandshakeLock);
@@ -701,7 +695,11 @@ _mongoc_handshake_build_doc_with_application (const char *appname)
                     doc (kv ("name", cstr (env_name)),
                          if (md->env_timeout_sec.set, then (kv ("timeout_sec", int32 (md->env_timeout_sec.value)))),
                          if (md->env_memory_mb.set, then (kv ("memory_mb", int32 (md->env_memory_mb.value)))),
-                         if (md->env_region, then (kv ("region", cstr (md->env_region)))))))));
+                         if (md->env_region, then (kv ("region", cstr (md->env_region)))))))),
+      if (md->kubernetes || md->docker,
+          then (kv ("container",
+                    doc (if (md->docker, then (kv ("runtime", cstr ("docker")))),
+                         if (md->kubernetes, then (kv ("orchestrator", cstr ("kubernetes")))))))));
 
    if (md->platform) {
       _append_platform_field (doc, md->platform, false);

src/libmongoc/tests/test-mongoc-handshake.c

@@ -399,6 +399,7 @@ clear_faas_env (void)
    ASSERT (_mongoc_setenv ("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", ""));
    ASSERT (_mongoc_setenv ("FUNCTIONS_WORKER_RUNTIME", ""));
    ASSERT (_mongoc_setenv ("K_SERVICE", ""));
+   ASSERT (_mongoc_setenv ("KUBERNETES_SERVICE_HOST", ""));
    ASSERT (_mongoc_setenv ("FUNCTION_MEMORY_MB", ""));
    ASSERT (_mongoc_setenv ("FUNCTION_TIMEOUT_SEC", ""));
    ASSERT (_mongoc_setenv ("FUNCTION_REGION", ""));
@@ -646,6 +647,28 @@ test_aws_not_lambda (void *test_ctx)
    _reset_handshake ();
 }
 
+static void
+test_aws_and_container (void *test_ctx)
+{
+   BSON_UNUSED (test_ctx);
+   ASSERT (_mongoc_setenv ("AWS_EXECUTION_ENV", "AWS_Lambda_java8"));
+   ASSERT (_mongoc_setenv ("AWS_REGION", "us-east-2"));
+   ASSERT (_mongoc_setenv ("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "1024"));
+   ASSERT (_mongoc_setenv ("KUBERNETES_SERVICE_HOST", "1"));
+
+   _override_host_platform_os ();
+   bson_t *doc = _get_handshake_document (true);
+   _handshake_check_required_fields (doc);
+
+   ASSERT_CMPSTR (bson_lookup_utf8 (doc, "container.orchestrator"), "kubernetes");
+   ASSERT_CMPSTR (bson_lookup_utf8 (doc, "env.name"), "aws.lambda");
+   _handshake_check_env (doc, default_memory_mb, 0, "us-east-2");
+
+   bson_destroy (doc);
+   clear_faas_env ();
+   _reset_handshake ();
+}
+
 static void
 test_mongoc_handshake_data_append_null_args (void)
 {
@@ -1399,4 +1422,10 @@ test_handshake_install (TestSuite *suite)
                       NULL /* dtor */,
                       NULL /* ctx */,
                       test_framework_skip_if_no_setenv);
+   TestSuite_AddFull (suite,
+                      "/MongoDB/handshake/faas/aws_and_container",
+                      test_aws_and_container,
+                      NULL /* dtor */,
+                      NULL /* ctx */,
+                      test_framework_skip_if_no_setenv);
 }