couchbase 3.2.2 → 3.2.5

package/deps/lcb/tests/iotests/t_views.cc

@@ -243,6 +243,7 @@ TEST_F(ViewsUnitTest, testSimpleView)
 {
     SKIP_UNLESS_MOCK();
     // Requires beer-sample
+    MockEnvironment *mock = MockEnvironment::getInstance();
     HandleWrap hw;
     lcb_INSTANCE *instance;
     connectBeerSample(hw, &instance);

package/deps/lcb/tests/iotests/testutil.cc

@@ -316,6 +316,10 @@ static std::uint64_t get_manifest_id(lcb_INSTANCE *instance)
     lcb_cmdgetmanifest_destroy(cmd);
     lcb_wait(instance, LCB_WAIT_DEFAULT);
 
+    if (result.rc == LCB_ERR_TIMEOUT) {
+        return 0;
+    }
+
     Json::Value payload;
     EXPECT_EQ(LCB_SUCCESS, result.rc);
     EXPECT_FALSE(result.value.empty());
@@ -461,3 +465,341 @@ std::string unique_name(const std::string &prefix)
     ss << prefix << lcb_next_rand32();
     return ss.str();
 }
+
+void TestSpan::SetAttribute(std::string key, uint64_t value)
+{
+    int_tags[std::move(key)] = value;
+}
+
+void TestSpan::SetAttribute(std::string key, std::string value)
+{
+    str_tags[std::move(key)] = std::move(value);
+}
+
+void TestSpan::End()
+{
+    finished = true;
+}
+
+TestSpan::TestSpan(std::string span_name)
+{
+    name = std::move(span_name);
+}
+
+std::shared_ptr<TestSpan> TestTracer::StartSpan(std::string name)
+{
+    auto t_span = std::make_shared<TestSpan>(name);
+    spans.push_back(t_span);
+    return t_span;
+}
+
+void TestTracer::reset()
+{
+    spans.clear();
+}
+
+static void *start_span(lcbtrace_TRACER *tracer, const char *name, void *parent)
+{
+    auto test_tracer = static_cast<TestTracer *>(tracer->cookie);
+    if (!test_tracer->enabled()) {
+        return nullptr;
+    }
+    auto test_span = test_tracer->StartSpan(std::string(name));
+    return test_span.get();
+}
+
+static void end_span(void *span)
+{
+    if (span == nullptr) {
+        return;
+    }
+    static_cast<TestSpan *>(span)->End();
+}
+
+static void add_tag_string(void *span, const char *name, const char *value, size_t value_len)
+{
+    if (span == nullptr) {
+        return;
+    }
+    std::string val;
+    val.append(value, value_len);
+    static_cast<TestSpan *>(span)->SetAttribute(std::string(name), val);
+}
+
+static void add_tag_uint64(void *span, const char *name, uint64_t value)
+{
+    if (span == nullptr) {
+        return;
+    }
+    static_cast<TestSpan *>(span)->SetAttribute(name, value);
+}
+
+void TestTracer::create_lcb_tracer()
+{
+    lcbtracer_ = lcbtrace_new(nullptr, LCBTRACE_F_EXTERNAL);
+    lcbtracer_->version = 1;
+    lcbtracer_->v.v1.start_span = start_span;
+    lcbtracer_->v.v1.end_span = end_span;
+    lcbtracer_->v.v1.add_tag_string = add_tag_string;
+    lcbtracer_->v.v1.add_tag_uint64 = add_tag_uint64;
+    lcbtracer_->cookie = static_cast<void *>(this);
+}
+
+void TestTracer::destroy_lcb_tracer()
+{
+    if (lcbtracer_ != nullptr) {
+        lcbtrace_destroy(lcbtracer_);
+        delete lcbtracer_;
+        lcbtracer_ = nullptr;
+    }
+}
+
+TestTracer::~TestTracer()
+{
+    destroy_lcb_tracer();
+}
+
+TestMeter::TestMeter() = default;
+
+void TestMeter::reset()
+{
+    recorders.clear();
+}
+
+void TestValueRecorder::RecordValue(uint64_t value)
+{
+    values.push_back(value);
+}
+
+std::shared_ptr<TestValueRecorder> TestMeter::ValueRecorder(std::string name,
+                                                            std::unordered_map<std::string, std::string> tags)
+{
+    auto key = name + ":" + tags["db.couchbase.service"];
+    auto op = tags["db.operation"];
+    if (!op.empty()) {
+        key = key + ":" + op;
+    }
+    std::shared_ptr<TestValueRecorder> test_recorder;
+    if (recorders.find(key) == recorders.end()) {
+        test_recorder = std::make_shared<TestValueRecorder>();
+        recorders[key] = test_recorder;
+    } else {
+        test_recorder = recorders[key];
+    }
+    return test_recorder;
+}
+
+static void record_callback(const lcbmetrics_VALUERECORDER *recorder, uint64_t value)
+{
+    void *test_recorder;
+    lcbmetrics_valuerecorder_cookie(recorder, &test_recorder);
+    static_cast<TestValueRecorder *>(test_recorder)->RecordValue(value);
+}
+
+static const lcbmetrics_VALUERECORDER *new_recorder(const lcbmetrics_METER *meter, const char *name,
+                                                    const lcbmetrics_TAG *tags, size_t ntags)
+{
+    std::unordered_map<std::string, std::string> recorder_tags;
+    for (int i = 0; i < ntags; i++) {
+        recorder_tags[tags[i].key] = tags[i].value;
+    }
+
+    void *test_meter_;
+    lcbmetrics_meter_cookie(meter, &test_meter_);
+    auto test_meter = static_cast<TestMeter *>(test_meter_);
+    auto test_value_recorder = test_meter->ValueRecorder(std::string(name), recorder_tags);
+
+    lcbmetrics_VALUERECORDER *recorder;
+    lcbmetrics_valuerecorder_create(&recorder, test_value_recorder.get());
+    lcbmetrics_valuerecorder_record_value_callback(recorder, record_callback);
+
+    return recorder;
+}
+
+void TestMeter::create_lcb_meter()
+{
+    lcbmetrics_meter_create(&lcbmeter_, static_cast<void *>(this));
+    lcbmetrics_meter_value_recorder_callback(lcbmeter_, new_recorder);
+}
+
+void TestMeter::destroy_lcb_meter()
+{
+    if (lcbmeter_ != nullptr) {
+        lcbmetrics_meter_destroy(lcbmeter_);
+        lcbmeter_ = nullptr;
+    }
+}
+
+void enforce_rate_limits(lcb_INSTANCE *instance)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/internalSettings";
+    std::string body = "enforceLimits=true";
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_POST);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void create_rate_limited_user(lcb_INSTANCE *instance, const std::string &username, const rate_limits &limits)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/settings/rbac/users/local/" + username;
+    std::string body = "password=password&roles=admin";
+    Json::Value json_limits;
+    if (limits.kv_limits.enforce) {
+        Json::Value kv_limits;
+        if (limits.kv_limits.num_connections > 0) {
+            kv_limits["num_connections"] = limits.kv_limits.num_connections;
+        }
+        if (limits.kv_limits.num_ops_per_min > 0) {
+            kv_limits["num_ops_per_min"] = limits.kv_limits.num_ops_per_min;
+        }
+        if (limits.kv_limits.ingress_mib_per_min > 0) {
+            kv_limits["ingress_mib_per_min"] = limits.kv_limits.ingress_mib_per_min;
+        }
+        if (limits.kv_limits.egress_mib_per_min > 0) {
+            kv_limits["egress_mib_per_min"] = limits.kv_limits.egress_mib_per_min;
+        }
+        json_limits["kv"] = kv_limits;
+    }
+    if (limits.query_limits.enforce) {
+        Json::Value query_limits;
+        if (limits.query_limits.num_concurrent_requests > 0) {
+            query_limits["num_concurrent_requests"] = limits.query_limits.num_concurrent_requests;
+        }
+        if (limits.query_limits.num_queries_per_min > 0) {
+            query_limits["num_queries_per_min"] = limits.query_limits.num_queries_per_min;
+        }
+        if (limits.query_limits.ingress_mib_per_min > 0) {
+            query_limits["ingress_mib_per_min"] = limits.query_limits.ingress_mib_per_min;
+        }
+        if (limits.query_limits.egress_mib_per_min > 0) {
+            query_limits["egress_mib_per_min"] = limits.query_limits.egress_mib_per_min;
+        }
+        json_limits["query"] = query_limits;
+    }
+    if (limits.search_limits.enforce) {
+        Json::Value fts_limits;
+        if (limits.search_limits.num_concurrent_requests > 0) {
+            fts_limits["num_concurrent_requests"] = limits.search_limits.num_concurrent_requests;
+        }
+        if (limits.search_limits.num_queries_per_min > 0) {
+            fts_limits["num_queries_per_min"] = limits.search_limits.num_queries_per_min;
+        }
+        if (limits.search_limits.ingress_mib_per_min > 0) {
+            fts_limits["ingress_mib_per_min"] = limits.search_limits.ingress_mib_per_min;
+        }
+        if (limits.search_limits.egress_mib_per_min > 0) {
+            fts_limits["egress_mib_per_min"] = limits.search_limits.egress_mib_per_min;
+        }
+        json_limits["fts"] = fts_limits;
+    }
+    std::string j_limits = Json::FastWriter().write(json_limits);
+    body += "&limits=" + j_limits;
+    std::string content_type = "application/x-www-form-urlencoded";
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_PUT);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+    lcb_cmdhttp_content_type(cmd, content_type.c_str(), content_type.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void create_rate_limited_scope(lcb_INSTANCE *instance, const std::string &bucket, std::string &scope,
+                               const scope_rate_limits &limits)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/pools/default/buckets/" + bucket + "/scopes";
+    std::string body = "name=" + scope;
+    Json::Value json_limits;
+    if (limits.kv_scope_limits.enforce) {
+        Json::Value kv_limits;
+        kv_limits["data_size"] = limits.kv_scope_limits.data_size;
+        json_limits["kv"] = kv_limits;
+    }
+    if (limits.index_scope_limits.enforce) {
+        Json::Value index_limits;
+        index_limits["num_indexes"] = limits.index_scope_limits.num_indexes;
+        json_limits["index"] = index_limits;
+    }
+    std::string j_limits = Json::FastWriter().write(json_limits);
+    body += "&limits=" + j_limits;
+    std::string content_type = "application/x-www-form-urlencoded";
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_POST);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+    lcb_cmdhttp_content_type(cmd, content_type.c_str(), content_type.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void drop_user(lcb_INSTANCE *instance, const std::string &username)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/settings/rbac/users/local/" + username;
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_DELETE);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void create_search_index(lcb_INSTANCE *instance, const std::string &index_name, const std::string &type,
+                         const std::string &source_type, const std::string &source_name)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/api/index/" + index_name;
+    Json::Value json_body;
+    json_body["name"] = index_name;
+    json_body["type"] = type;
+    json_body["sourceName"] = source_name;
+    json_body["sourceType"] = source_type;
+
+    auto body = Json::FastWriter().write(json_body);
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_SEARCH);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_PUT);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}

package/deps/lcb/tests/iotests/testutil.h

@@ -20,6 +20,8 @@
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/vbucket.h>
 #include <string>
+#include <memory>
+#include <unordered_map>
 
 #define ASSERT_STATUS_EQ(expected, actual)                                                                             \
     lcb_STATUS GTEST_CONCAT_TOKEN_(actual_code__, __LINE__) = (actual);                                                \
@@ -212,4 +214,166 @@ void drop_scope(lcb_INSTANCE *instance, const std::string &scope, bool wait = tr
 void drop_collection(lcb_INSTANCE *instance, const std::string &scope, const std::string &collection, bool wait = true);
 
 std::string unique_name(const std::string &);
+
+class TestSpan
+{
+  public:
+    explicit TestSpan(std::string name);
+    void SetAttribute(std::string key, std::string value);
+    void SetAttribute(std::string key, uint64_t value);
+    void End();
+
+    std::unordered_map<std::string, std::string> str_tags{};
+    std::unordered_map<std::string, uint64_t> int_tags{};
+    bool finished{false};
+    std::string name{};
+
+    TestSpan *parent{nullptr};
+};
+
+class TestTracer
+{
+  public:
+    TestTracer() = default;
+    ~TestTracer();
+    std::shared_ptr<TestSpan> StartSpan(std::string name);
+
+    std::vector<std::shared_ptr<TestSpan>> spans{};
+
+    void reset();
+
+    bool set_enabled(bool new_value)
+    {
+        bool old_value = enabled_;
+        enabled_ = new_value;
+
+        reset();
+        destroy_lcb_tracer();
+        if (new_value) {
+            create_lcb_tracer();
+        }
+        return old_value;
+    }
+
+    bool enabled() const
+    {
+        return enabled_;
+    }
+
+    lcbtrace_TRACER *lcb_tracer()
+    {
+        return lcbtracer_;
+    }
+
+  private:
+    void create_lcb_tracer();
+    void destroy_lcb_tracer();
+
+    lcbtrace_TRACER *lcbtracer_{nullptr};
+    bool enabled_{false};
+};
+
+class TestValueRecorder
+{
+  public:
+    TestValueRecorder() = default;
+    void RecordValue(uint64_t value);
+
+    std::vector<uint64_t> values{};
+};
+
+class TestMeter
+{
+  public:
+    TestMeter();
+    void reset();
+    std::shared_ptr<TestValueRecorder> ValueRecorder(std::string name,
+                                                     std::unordered_map<std::string, std::string> tags);
+
+    std::unordered_map<std::string, std::shared_ptr<TestValueRecorder>> recorders{};
+
+    bool set_enabled(bool new_value)
+    {
+        bool old_value = enabled_;
+        enabled_ = new_value;
+
+        reset();
+        destroy_lcb_meter();
+        if (new_value) {
+            create_lcb_meter();
+        }
+        return old_value;
+    }
+
+    bool enabled() const
+    {
+        return enabled_;
+    }
+
+    lcbmetrics_METER *lcb_meter()
+    {
+        return lcbmeter_;
+    }
+
+  private:
+    void create_lcb_meter();
+    void destroy_lcb_meter();
+
+    lcbmetrics_METER *lcbmeter_{nullptr};
+    bool enabled_{false};
+};
+
+struct kv_rate_limits {
+    uint32_t num_connections{0};
+    uint32_t num_ops_per_min{0};
+    uint32_t ingress_mib_per_min{0};
+    uint32_t egress_mib_per_min{0};
+    bool enforce{false};
+};
+
+struct query_rate_limits {
+    uint32_t ingress_mib_per_min{0};
+    uint32_t egress_mib_per_min{0};
+    uint32_t num_concurrent_requests{0};
+    uint32_t num_queries_per_min{0};
+    bool enforce{false};
+};
+
+struct search_rate_limits {
+    uint32_t ingress_mib_per_min{0};
+    uint32_t egress_mib_per_min{0};
+    uint32_t num_concurrent_requests{0};
+    uint32_t num_queries_per_min{0};
+    bool enforce{false};
+};
+
+struct rate_limits {
+    kv_rate_limits kv_limits{};
+    query_rate_limits query_limits{};
+    search_rate_limits search_limits{};
+};
+
+struct kv_scope_rate_limits {
+    uint32_t data_size;
+    bool enforce{false};
+};
+
+struct index_scope_rate_limits {
+    uint32_t num_indexes{0};
+    bool enforce{false};
+};
+
+struct scope_rate_limits {
+    kv_scope_rate_limits kv_scope_limits;
+    index_scope_rate_limits index_scope_limits;
+};
+
+void enforce_rate_limits(lcb_INSTANCE *instance);
+void create_rate_limited_user(lcb_INSTANCE *instance, const std::string &username, const rate_limits &limits);
+void drop_user(lcb_INSTANCE *instance, const std::string &username);
+void create_rate_limited_scope(lcb_INSTANCE *instance, const std::string &bucket, std::string &scope,
+                               const scope_rate_limits &limits);
+void create_search_index(lcb_INSTANCE *instance, const std::string &index_name, const std::string &type,
+                         const std::string &source_type, const std::string &source_name);
+
 #endif

package/deps/lcb/tests/mocksupport/procutil.c

@@ -20,8 +20,6 @@
 #include <stdio.h>
 
 #ifndef _WIN32
-#define _XOPEN_SOURCE
-#include <stdlib.h>
 #include <string.h>
 #include <wordexp.h>
 #include <fcntl.h>  /* O_* */
@@ -51,6 +49,7 @@ static char **clisplit(const char *s)
         ret[ii] = strdup(p.we_wordv[ii]);
     }
     ret[ii] = NULL;
+    wordfree(&p);
     return ret;
 }
 
@@ -59,39 +58,44 @@ static int spawn_process_impl(child_process_t *proc)
     int rv;
     char **argv;
 
-    proc->pid = fork();
-    if (proc->pid < 0) {
+    argv = clisplit(proc->name);
+    if (argv == NULL) {
+        fprintf(stderr, "Couldn't split arguments: %s\n", proc->name);
         return -1;
     }
-    if (proc->pid > 0) {
-        return 0;
-    }
-
-    /** In Child */
-    argv = clisplit(proc->name);
-    if (!argv) {
-        fprintf(stderr, "Couldn't split arguments\n");
-        exit(EXIT_FAILURE);
+    proc->pid = vfork();
+    if (proc->pid < 0) {
+        for (int i = 0; argv[i] != NULL; ++i) {
+            free(argv[i]);
+        }
+        free(argv);
+        return -1;
     }
-    if (proc->redirect) {
-        int fd = open(proc->redirect, O_RDWR | O_CREAT | O_APPEND, 0644);
-        if (fd < 0) {
-            perror(proc->redirect);
-            exit(EXIT_FAILURE);
+    if (proc->pid == 0) {
+        /** In Child */
+        if (proc->redirect) {
+            int fd = open(proc->redirect, O_RDWR | O_CREAT | O_APPEND, 0644);
+            if (fd < 0) {
+                perror(proc->redirect);
+                exit(EXIT_FAILURE);
+            }
+            if (dup2(fd, fileno(stderr)) < 0 || dup2(fd, fileno(stdout)) < 0) {
+                perror("dup2");
+                exit(EXIT_FAILURE);
+            }
+            setvbuf(stderr, NULL, _IOLBF, 0);
         }
-        if (dup2(fd, fileno(stderr)) < 0 || dup2(fd, fileno(stdout)) < 0) {
-            perror("dup2");
-            exit(EXIT_FAILURE);
+        rv = execvp(argv[0], argv);
+        if (rv < 0) {
+            perror(argv[0]);
+            return -1;
         }
-        setvbuf(stderr, NULL, _IOLBF, 0);
     }
-    rv = execvp(argv[0], argv);
-    if (rv < 0) {
-        perror(argv[0]);
-        exit(EXIT_FAILURE);
+    for (int i = 0; argv[i] != NULL; ++i) {
+        free(argv[i]);
     }
-    abort();
-    return 0; /* make things happy */
+    free(argv);
+    return 0;
 }
 
 void kill_process(child_process_t *process, int force)

package/deps/lcb/tests/mocksupport/server.c

@@ -296,7 +296,6 @@ static int start_mock_server(struct test_server_info *info, char **cmdline)
 
     start_mock_process(info, argv);
     negotiate_mock_connection(info);
-    sleep(1); /* give it a bit time to initialize itself */
     return 1;
 }
 

package/deps/lcb/tools/cbc.cc

@@ -1273,6 +1273,13 @@ void VersionHandler::run()
 #endif
         printf("  SSL Headers: %s\n", OPENSSL_VERSION_TEXT);
 #endif
+        printf("  HAVE_PKCS5_PBKDF2_HMAC: "
+#ifdef HAVE_PKCS5_PBKDF2_HMAC
+               "yes"
+#else
+               "no"
+#endif
+               "\n");
     } else {
         printf("  SSL: NOT SUPPORTED\n");
     }

package/dist/analyticsexecutor.js

@@ -82,8 +82,8 @@ class AnalyticsExecutor {
                 }
                 const metricsData = metaData.metrics || {};
                 const metrics = new analyticstypes_1.AnalyticsMetrics({
-                    elapsedTime: utilities_1.goDurationStrToMs(metricsData.elapsedTime) || 0,
-                    executionTime: utilities_1.goDurationStrToMs(metricsData.executionTime) || 0,
+                    elapsedTime: (0, utilities_1.goDurationStrToMs)(metricsData.elapsedTime) || 0,
+                    executionTime: (0, utilities_1.goDurationStrToMs)(metricsData.executionTime) || 0,
                     resultCount: metricsData.resultCount || 0,
                     resultSize: metricsData.resultSize || 0,
                     errorCount: metricsData.errorCount || 0,