@cloudcare/cocos-sdk 0.1.1-alpha.2 → 0.1.1-alpha.4

package/dist/creator2/core/auto-tracking.js

@@ -1,62 +1,7 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FTDefaultAutoTracking = void 0;
+var observation_js_1 = require("./observation.js");
 var FTDefaultAutoTracking = /** @class */ (function () {
     function FTDefaultAutoTracking(rum, logger, trace, hooks, target) {
         if (target === void 0) { target = globalThis; }
@@ -67,6 +12,7 @@ var FTDefaultAutoTracking = /** @class */ (function () {
         this.target = target;
         this.stops = [];
         this.networkStops = [];
+        this.observations = new observation_js_1.FTObservationQueue(target);
     }
     FTDefaultAutoTracking.prototype.start = function (config, viewName, scope) {
         if (scope === void 0) { scope = 'all'; }
@@ -113,6 +59,7 @@ var FTDefaultAutoTracking = /** @class */ (function () {
         if (scope !== 'page')
             this.networkStops.splice(0).reverse().forEach(cleanup);
         if (scope !== 'network') {
+            this.observations.stop();
             this.stops.splice(0).reverse().forEach(cleanup);
             if (this.activeView) {
                 cleanup(function () { return _this.rum.stopView(); });
@@ -140,6 +87,29 @@ var FTDefaultAutoTracking = /** @class */ (function () {
     };
     FTDefaultAutoTracking.prototype.installErrorTracking = function () {
         var _this = this;
+        var _a;
+        var nativeErrors = this.target.__FT_COCOS_JSB_ERRORS__;
+        if ((nativeErrors === null || nativeErrors === void 0 ? void 0 : nativeErrors.protocol) === 2) {
+            this.stops.push(nativeErrors.subscribe(function (location, message, stack) {
+                var _a;
+                // Creator 2 also reports promise bookkeeping notifications through onError.
+                if (message === 'handlerAddedAfterPromiseRejected' || message === 'rejectAfterPromiseResolved'
+                    || message === 'resolveAfterPromiseResolved')
+                    return;
+                var rejection = message === 'unhandledRejectedPromise';
+                var reason = rejection ? (_a = stack.split(/\r?\n/, 1)[0]) === null || _a === void 0 ? void 0 : _a.replace(/^Error:\s*/, '') : message;
+                var errorMessage = reason || message || 'Uncaught JavaScript error';
+                var errorStack = stack || location || '';
+                var type = rejection ? 'unhandled_promise_rejection' : 'cocos_error';
+                _this.observations.enqueue(function () {
+                    _this.rum.addError(errorMessage, errorStack, type);
+                }, 2 * (location.length + message.length + stack.length));
+            }));
+            return;
+        }
+        if (nativeErrors || typeof ((_a = this.target.jsb) === null || _a === void 0 ? void 0 : _a.onError) === 'function') {
+            throw new Error('Cocos native error bootstrap is missing. Rerun the SDK installer and rebuild the native project.');
+        }
         if (!this.target.addEventListener || !this.target.removeEventListener)
             return;
         var errorListener = function (event) {
@@ -170,24 +140,51 @@ var FTDefaultAutoTracking = /** @class */ (function () {
             'warn',
             'error',
         ];
+        var observations = this.observations;
+        var state = (0, observation_js_1.observationState)(this.target);
         var originals = new Map();
+        var wrappers = new Map();
+        var active = true;
         methods.forEach(function (method) {
-            var original = consoleObject[method].bind(consoleObject);
+            var original = consoleObject[method];
             originals.set(method, original);
-            consoleObject[method] = (function () {
+            var logger = _this.logger;
+            consoleObject[method] = function () {
                 var args = [];
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                original.apply(void 0, args);
-                var level = method === 'warn' ? 'warning' : method === 'error' ? 'error' : 'info';
-                _this.logger.log(args.map(stringifyLogValue).join(' '), level);
-            });
+                var snapshot;
+                try {
+                    if (active && !state.reporting)
+                        snapshot = { timestampMs: Date.now(), values: args.slice(0, 16) };
+                }
+                catch ( /* Snapshot failures cannot prevent the original console call. */_a) { /* Snapshot failures cannot prevent the original console call. */ }
+                // Keep the original receiver, result and thrown value. No SDK work can
+                // escape this finally block and replace the original console outcome.
+                try {
+                    return original.apply(this, args);
+                }
+                finally {
+                    try {
+                        if (active && snapshot) {
+                            var timestampMs_1 = snapshot.timestampMs, values_1 = snapshot.values;
+                            observations.enqueue(function () {
+                                var level = method === 'warn' ? 'warning' : method === 'error' ? 'error' : 'info';
+                                logger.log(values_1.map(stringifyLogValue).join(' '), level, { cocos_observed_at_ms: timestampMs_1 });
+                            }, values_1.reduce(function (size, value) { return size + (typeof value === 'string' ? value.length * 2 : 64); }, 0));
+                        }
+                    }
+                    catch ( /* Logging must never change application console behavior. */_b) { /* Logging must never change application console behavior. */ }
+                }
+            };
+            wrappers.set(method, consoleObject[method]);
         });
         this.stops.push(function () {
+            active = false;
             methods.forEach(function (method) {
                 var original = originals.get(method);
-                if (original)
+                if (original && consoleObject[method] === wrappers.get(method))
                     consoleObject[method] = original;
             });
         });
@@ -197,46 +194,93 @@ var FTDefaultAutoTracking = /** @class */ (function () {
         var original = this.target.fetch;
         if (!original)
             return;
-        var tracked = (function (input, init) { return __awaiter(_this, void 0, void 0, function () {
-            var inputObject, url, method, key, headers, start, response, end, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        inputObject = typeof input === 'object' ? input : undefined;
-                        url = typeof input === 'string' ? input : (inputObject === null || inputObject === void 0 ? void 0 : inputObject.url) || String(input);
-                        method = (init === null || init === void 0 ? void 0 : init.method) || (inputObject === null || inputObject === void 0 ? void 0 : inputObject.method) || 'GET';
-                        key = resourceKey();
-                        headers = createHeaders((init === null || init === void 0 ? void 0 : init.headers) || (inputObject === null || inputObject === void 0 ? void 0 : inputObject.headers));
-                        forEachOwn(this.trace.getHeaders(url, key), function (name, value) { return setHeader(headers, name, value); });
-                        this.rum.startResource(key);
-                        start = nowNs();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, original(input, __assign(__assign({}, init), { headers: headers }))];
-                    case 2:
-                        response = _a.sent();
-                        end = nowNs();
-                        this.rum.stopResource(key);
-                        this.rum.addResource(key, {
-                            url: url,
-                            httpMethod: method,
-                            requestHeaders: headersToObject(headers),
-                            responseHeaders: headersToObject(response.headers),
-                            statusCode: response.status,
-                        }, { fetchStartTime: start, responseStartTime: end, responseEndTime: end });
-                        return [2 /*return*/, response];
-                    case 3:
-                        error_1 = _a.sent();
-                        this.rum.stopResource(key);
-                        this.rum.addError(String(error_1), error_1 instanceof Error ? error_1.stack || '' : '', 'network_error');
-                        throw error_1;
-                    case 4: return [2 /*return*/];
+        var rum = this.rum;
+        var trace = this.trace;
+        var active = true;
+        var tracked = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (!active)
+                return original.apply(this, args);
+            var outgoing = args;
+            var data;
+            observeNetwork(function () {
+                var input = args[0], init = args[1];
+                var inputObject = networkInput(input);
+                if (!inputObject)
+                    return;
+                var url = inputObject.url;
+                var method = networkOption(init, 'method');
+                var sourceHeaders = networkOption(init, 'headers');
+                var record = { key: resourceKey(), url: url, method: method || inputObject.method || 'GET',
+                    start: nowNs(), headers: undefined };
+                data = record;
+                try {
+                    var headers_1 = createHeaders(sourceHeaders === undefined ? inputObject.headers : sourceHeaders);
+                    var appended_1 = false;
+                    forEachOwn(trace.getHeaders(url, record.key), function (name, value) {
+                        if (!hasHeader(headers_1, name)) {
+                            appendHeader(headers_1, name, value);
+                            appended_1 = true;
+                        }
+                    });
+                    if (appended_1) {
+                        outgoing = args.slice();
+                        outgoing[1] = withRequestHeaders(init, headers_1);
+                    }
+                    record.headers = headers_1;
                 }
+                catch ( /* Failed instrumentation leaves the original fetch arguments intact. */_a) { /* Failed instrumentation leaves the original fetch arguments intact. */ }
+                observeNetwork(function () { return rum.startResource(record.key); });
             });
-        }); });
+            var reportFailure = function (error) {
+                if (!data)
+                    return;
+                var key = data.key;
+                observeNetwork(function () { return rum.stopResource(key); });
+                observeNetwork(function () { return rum.addError(String(error), error instanceof Error ? error.stack || '' : '', 'network_error'); });
+            };
+            var result;
+            // Invoke the application request once. Observation failures must never retry it.
+            try {
+                result = original.apply(this, outgoing);
+            }
+            catch (error) {
+                reportFailure(error);
+                throw error;
+            }
+            if (!data)
+                return result;
+            var record = data;
+            try {
+                return result.then(function (response) {
+                    observeNetwork(function () { return rum.stopResource(record.key); });
+                    observeNetwork(function () {
+                        var end = nowNs();
+                        rum.addResource(record.key, {
+                            url: record.url,
+                            httpMethod: record.method,
+                            requestHeaders: record.headers && headersToObject(record.headers),
+                            responseHeaders: headersToObject(response.headers),
+                            statusCode: response.status,
+                        }, { fetchStartTime: record.start, responseStartTime: end, responseEndTime: end });
+                    });
+                    return response;
+                }, function (error) {
+                    reportFailure(error);
+                    throw error;
+                });
+            }
+            catch (_a) {
+                return result;
+            }
+        };
         this.networkStops.push(function () {
-            _this.target.fetch = original;
+            active = false;
+            if (_this.target.fetch === tracked)
+                _this.target.fetch = original;
         });
         this.target.fetch = tracked;
     };
@@ -250,71 +294,155 @@ var FTDefaultAutoTracking = /** @class */ (function () {
         var metadata = new WeakMap();
         var rum = this.rum;
         var trace = this.trace;
-        // Register each restore before assignment so partial installation can roll back.
-        this.networkStops.push(function () { Xhr.prototype.open = open; });
-        Xhr.prototype.open = function trackedOpen(method, url) {
-            var _a;
-            var rest = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                rest[_i - 2] = arguments[_i];
+        var active = true;
+        var trackedOpen = function () {
+            var _this = this;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (!active)
+                return open.apply(this, args);
+            var previous = metadata.get(this);
+            observeNetwork(function () {
+                metadata.delete(_this);
+                if (typeof args[0] !== 'string' || typeof args[1] !== 'string')
+                    return;
+                metadata.set(_this, { key: resourceKey(), method: args[0], url: String(args[1]),
+                    headers: Object.create(null), headersKnown: true });
+            });
+            try {
+                return open.apply(this, args);
+            }
+            catch (error) {
+                observeNetwork(function () { if (previous)
+                    metadata.set(_this, previous);
+                else
+                    metadata.delete(_this); });
+                throw error;
             }
-            metadata.set(this, { key: resourceKey(), method: method, url: String(url), headers: {} });
-            (_a = open).call.apply(_a, __spreadArray([this, method, url], rest, false));
         };
-        this.networkStops.push(function () { Xhr.prototype.setRequestHeader = setRequestHeader; });
-        Xhr.prototype.setRequestHeader = function trackedHeader(name, value) {
-            var data = metadata.get(this);
-            if (data)
-                data.headers[name] = value;
-            setRequestHeader.call(this, name, value);
+        // Register each restore before assignment so partial installation can roll back.
+        this.networkStops.push(function () { active = false; if (Xhr.prototype.open === trackedOpen)
+            Xhr.prototype.open = open; });
+        Xhr.prototype.open = trackedOpen;
+        var trackedHeader = function () {
+            var _this = this;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var result = setRequestHeader.apply(this, args);
+            observeNetwork(function () {
+                var data = active && metadata.get(_this);
+                if (!data)
+                    return;
+                var name = args[0], value = args[1];
+                if (typeof name !== 'string' || typeof value !== 'string') {
+                    data.headersKnown = false;
+                    return;
+                }
+                var key = name.toLowerCase();
+                data.headers[key] = key in data.headers ? "".concat(data.headers[key], ", ").concat(value) : value;
+            });
+            return result;
         };
-        this.networkStops.push(function () { Xhr.prototype.send = send; });
-        Xhr.prototype.send = function trackedSend(body) {
+        this.networkStops.push(function () {
+            active = false;
+            if (Xhr.prototype.setRequestHeader === trackedHeader)
+                Xhr.prototype.setRequestHeader = setRequestHeader;
+        });
+        Xhr.prototype.setRequestHeader = trackedHeader;
+        var trackedSend = function () {
             var _this = this;
-            var data = metadata.get(this);
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var data = active && metadata.get(this);
             if (!data)
-                return send.call(this, body);
-            forEachOwn(trace.getHeaders(data.url, data.key), function (name, value) {
-                data.headers[name] = value;
-                setRequestHeader.call(_this, name, value);
+                return send.apply(this, args);
+            observeNetwork(function () {
+                if (!data.headersKnown)
+                    return;
+                forEachOwn(trace.getHeaders(data.url, data.key), function (name, value) {
+                    if (!validTraceHeader(name, value))
+                        return;
+                    var key = name.toLowerCase();
+                    if (key in data.headers)
+                        return;
+                    setRequestHeader.call(_this, name, value);
+                    data.headers[key] = value;
+                });
             });
-            var started = nowNs();
-            rum.startResource(data.key);
+            var started = 0;
+            observeNetwork(function () { started = nowNs(); rum.startResource(data.key); });
             var completed = false;
+            var cleanup;
             var report = function () {
                 if (completed)
                     return;
                 completed = true;
-                var ended = nowNs();
-                rum.stopResource(data.key);
-                rum.addResource(data.key, {
-                    url: data.url,
-                    httpMethod: data.method,
-                    requestHeaders: data.headers,
-                    responseHeaders: parseXhrHeaders(_this.getAllResponseHeaders()),
-                    statusCode: _this.status,
-                }, { fetchStartTime: started, responseStartTime: ended, responseEndTime: ended });
+                observeNetwork(function () { return cleanup === null || cleanup === void 0 ? void 0 : cleanup(); });
+                observeNetwork(function () { return rum.stopResource(data.key); });
+                observeNetwork(function () {
+                    var ended = nowNs();
+                    rum.addResource(data.key, {
+                        url: data.url,
+                        httpMethod: data.method,
+                        requestHeaders: data.headers,
+                        responseHeaders: parseXhrHeaders(_this.getAllResponseHeaders()),
+                        statusCode: _this.status,
+                    }, { fetchStartTime: started, responseStartTime: ended, responseEndTime: ended });
+                });
             };
-            var originalLoadEnd = this.onloadend;
-            this.addEventListener('loadend', report, { once: true });
-            // Creator 2 JSB implements addEventListener by assigning the on* property.
-            // Preserve the business handler there; DOM runtimes already keep both listeners.
-            if (this.onloadend === report) {
-                var xhr_1 = this;
-                var handler_1 = function (event) {
-                    if (xhr_1.onloadend === handler_1)
-                        xhr_1.onloadend = originalLoadEnd;
-                    try {
-                        originalLoadEnd === null || originalLoadEnd === void 0 ? void 0 : originalLoadEnd.call(xhr_1, event);
+            observeNetwork(function () {
+                var originalLoadEnd = _this.onloadend;
+                try {
+                    _this.addEventListener('loadend', report, { once: true });
+                    // Creator 2 JSB assigns the on* property instead of keeping a listener list.
+                    if (_this.onloadend === report) {
+                        var xhr_1 = _this;
+                        var handler_1 = function () {
+                            var events = [];
+                            for (var _i = 0; _i < arguments.length; _i++) {
+                                events[_i] = arguments[_i];
+                            }
+                            observeNetwork(function () { return cleanup === null || cleanup === void 0 ? void 0 : cleanup(); });
+                            try {
+                                return originalLoadEnd === null || originalLoadEnd === void 0 ? void 0 : originalLoadEnd.apply(this, events);
+                            }
+                            finally {
+                                report();
+                            }
+                        };
+                        cleanup = function () { if (xhr_1.onloadend === handler_1)
+                            xhr_1.onloadend = originalLoadEnd; };
+                        _this.onloadend = handler_1;
                     }
-                    finally {
-                        report();
+                    else {
+                        cleanup = function () { return _this.removeEventListener('loadend', report); };
                     }
-                };
-                this.onloadend = handler_1;
+                }
+                catch (_a) {
+                    observeNetwork(function () { return cleanup === null || cleanup === void 0 ? void 0 : cleanup(); });
+                    observeNetwork(function () { if (_this.onloadend === report)
+                        _this.onloadend = originalLoadEnd; });
+                }
+            });
+            try {
+                return send.apply(this, args);
+            }
+            catch (error) {
+                completed = true;
+                observeNetwork(function () { return cleanup === null || cleanup === void 0 ? void 0 : cleanup(); });
+                observeNetwork(function () { return rum.stopResource(data.key); });
+                throw error;
             }
-            send.call(this, body);
         };
+        this.networkStops.push(function () { active = false; if (Xhr.prototype.send === trackedSend)
+            Xhr.prototype.send = send; });
+        Xhr.prototype.send = trackedSend;
     };
     return FTDefaultAutoTracking;
 }());
@@ -327,39 +455,107 @@ function resourceKey() {
     resourceSequence = (resourceSequence + 1) % Number.MAX_SAFE_INTEGER;
     return "cocos-".concat(Date.now().toString(36), "-").concat(resourceSequence.toString(36));
 }
+function observeNetwork(observe) {
+    try {
+        observe();
+    }
+    catch ( /* Monitoring cannot change the application's network result. */_a) { /* Monitoring cannot change the application's network result. */ }
+}
+function networkOption(init, name) {
+    for (var source = init; source; source = Object.getPrototypeOf(source)) {
+        var descriptor = Object.getOwnPropertyDescriptor(source, name);
+        if (!descriptor)
+            continue;
+        // Accessors may refresh tokens or mutate options. Leave them to the original fetch.
+        if (descriptor.get || descriptor.set)
+            throw new TypeError('Network option requires its original receiver');
+        return descriptor.value;
+    }
+    return undefined;
+}
+function networkInput(input) {
+    if (typeof input === 'string')
+        return { url: input };
+    if (typeof Request === 'function' && input instanceof Request) {
+        var read = function (name) {
+            var descriptor = Object.getOwnPropertyDescriptor(Request.prototype, name);
+            return (descriptor === null || descriptor === void 0 ? void 0 : descriptor.get) ? descriptor.get.call(input) : networkOption(input, name);
+        };
+        return { url: read('url'), method: read('method'), headers: read('headers') };
+    }
+    if (typeof URL === 'function' && input instanceof URL)
+        return { url: URL.prototype.toString.call(input) };
+    // Custom string conversion belongs to the application request and must only run there.
+    return undefined;
+}
+function withRequestHeaders(init, headers) {
+    var result = Object.create(init || null);
+    var _loop_1 = function (source) {
+        Object.getOwnPropertyNames(source).forEach(function (name) {
+            if (name === 'headers' || Object.prototype.hasOwnProperty.call(result, name))
+                return;
+            var descriptor = Object.getOwnPropertyDescriptor(source, name);
+            Object.defineProperty(result, name, { enumerable: descriptor === null || descriptor === void 0 ? void 0 : descriptor.enumerable, configurable: true,
+                get: function () { return init[name]; } });
+        });
+    };
+    // Forward getters to their original receiver, including inherited/non-enumerable options.
+    for (var source = init; source && source !== Object.prototype; source = Object.getPrototypeOf(source)) {
+        _loop_1(source);
+    }
+    Object.defineProperty(result, 'headers', { value: headers, enumerable: true, configurable: true, writable: true });
+    return result;
+}
 function createHeaders(source) {
     var HeadersConstructor = globalThis.Headers;
     if (HeadersConstructor)
         return new HeadersConstructor(source);
-    var result = {};
+    var result = [];
     if (Array.isArray(source)) {
         source.forEach(function (_a) {
             var name = _a[0], value = _a[1];
-            result[name] = String(value);
+            result.push([String(name), String(value)]);
         });
     }
     else if (source && typeof source.forEach === 'function') {
-        source.forEach(function (value, name) { result[name] = value; });
+        source.forEach(function (value, name) { result.push([name, value]); });
     }
     else if (source) {
-        forEachOwn(source, function (name, value) { result[name] = String(value); });
+        forEachOwn(source, function (name, value) { result.push([name, String(value)]); });
     }
     return result;
 }
-function setHeader(headers, name, value) {
-    if (typeof headers.set === 'function')
-        headers.set(name, value);
+function hasHeader(headers, name) {
+    return Array.isArray(headers) ? headers.some(function (_a) {
+        var key = _a[0];
+        return key.toLowerCase() === name.toLowerCase();
+    }) : headers.has(name);
+}
+function appendHeader(headers, name, value) {
+    if (!validTraceHeader(name, value))
+        throw new TypeError('Invalid trace header');
+    if (Array.isArray(headers))
+        headers.push([name, value]);
     else
-        headers[name] = value;
+        headers.append(name, value);
+}
+function validTraceHeader(name, value) {
+    return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name) && typeof value === 'string'
+        && !/[\x00-\x08\x0a-\x1f\x7f\u0100-\uffff]/.test(value);
 }
 function headersToObject(headers) {
-    var result = {};
-    if (typeof headers.forEach === 'function') {
-        headers.forEach(function (value, key) { result[key] = value; });
-    }
-    else {
-        forEachOwn(headers, function (key, value) { result[key] = value; });
-    }
+    var result = Object.create(null);
+    var append = function (value, name) {
+        var key = name.toLowerCase();
+        result[key] = key in result ? "".concat(result[key], ", ").concat(value) : value;
+    };
+    if (Array.isArray(headers))
+        headers.forEach(function (_a) {
+            var name = _a[0], value = _a[1];
+            return append(value, name);
+        });
+    else
+        headers.forEach(append);
     return result;
 }
 function forEachOwn(value, callback) {