.gitignore

@@ -31,3 +31,4 @@ Tests/FunctionalTests/TestApp/package-lock.json
 
 # Ignore log files
 npm-debug.log
+undefined/temp/appInsights-node/applicationinsights.log

AutoCollection/CorrelationContextManager.ts

@@ -197,8 +197,24 @@ export class CorrelationContextManager {
 
         // AzFunction TraceContext available
         if (traceContext) {
-            const traceparent = new Traceparent(traceContext.traceparent);
-            const tracestate = new Tracestate(traceContext.tracestate);
+            let traceparent = null;
+            let tracestate = null;
+            if ( (request as azureFunctionsTypes.HttpRequest).headers ) {
+                if( (request as azureFunctionsTypes.HttpRequest).headers.traceparent ) {
+                    traceparent = new Traceparent((request as azureFunctionsTypes.HttpRequest).headers.traceparent);
+                } else if ( (request as azureFunctionsTypes.HttpRequest).headers["request-id"] ) {
+                    traceparent = new Traceparent(null, (request as azureFunctionsTypes.HttpRequest).headers["request-id"]);
+                }
+                if( (request as azureFunctionsTypes.HttpRequest).headers.tracestate ) {
+                    tracestate = new Tracestate((request as azureFunctionsTypes.HttpRequest).headers.tracestate);
+                }
+            }
+            if( !traceparent ) {
+                traceparent = new Traceparent(traceContext.traceparent);
+            }
+            if( !tracestate ) {
+                tracestate = new Tracestate(traceContext.tracestate);
+            }
             const parser = typeof request === "object"
                 ? new HttpRequestParser(request)
                 : null;

AutoCollection/Exceptions.ts

@@ -1,7 +1,6 @@
 import http = require("http");
 
 import Contracts = require("../Declarations/Contracts");
-import Logging = require("../Library/Logging");
 import TelemetryClient = require("../Library/TelemetryClient");
 import Sender = require("../Library/Sender");
 import Queue = require("../Library/Channel");

AutoCollection/HttpDependencies.ts

@@ -72,7 +72,26 @@ class AutoCollectHttpDependencies {
 
             if (request && options && shouldCollect) {
                 CorrelationContextManager.wrapEmitter(request);
-                AutoCollectHttpDependencies.trackRequest(this._client, { options: options, request: request });
+                // If there is no context create one, this apply when no request is triggering the dependency
+                if (!CorrelationContextManager.getCurrentContext()) {
+                    // Create correlation context and wrap execution
+                    let operationId = null;
+                    if (CorrelationIdManager.w3cEnabled) {
+                        let traceparent = new Traceparent();
+                        operationId = traceparent.traceId;
+                    }
+                    else {
+                        let requestId = CorrelationIdManager.generateRequestId(null);
+                        operationId = CorrelationIdManager.getRootId(requestId);
+                    }
+                    let correlationContext = CorrelationContextManager.generateContextObject(operationId);
+                    CorrelationContextManager.runWithContext(correlationContext, () => {
+                        AutoCollectHttpDependencies.trackRequest(this._client, { options: options, request: request });
+                    });
+                }
+                else {
+                    AutoCollectHttpDependencies.trackRequest(this._client, { options: options, request: request });
+                }
             }
         };
 
@@ -169,7 +188,7 @@ class AutoCollectHttpDependencies {
                         if (currentContext.operation.tracestate) {
                             const tracestate = currentContext.operation.tracestate.toString();
                             if (tracestate) {
-                                telemetry.request.setHeader(RequestResponseHeaders.traceStateHeader, tracestate)
+                                telemetry.request.setHeader(RequestResponseHeaders.traceStateHeader, tracestate);
                             }
                         }
 

AutoCollection/HttpDependencyParser.ts

@@ -43,20 +43,22 @@ class HttpDependencyParser extends RequestParser {
      * Gets a dependency data contract object for a completed ClientRequest.
      */
     public getDependencyTelemetry(baseTelemetry?: Contracts.Telemetry, dependencyId?: string): Contracts.DependencyTelemetry {
-        let urlObject = new url.URL(this.url);
-        urlObject.search = undefined;
-        urlObject.hash = undefined;
-        let dependencyName = this.method.toUpperCase() + " " + urlObject.pathname;
-
-
+        let dependencyName = this.method.toUpperCase();
         let remoteDependencyType = Contracts.RemoteDependencyDataConstants.TYPE_HTTP;
+        let remoteDependencyTarget = "";
+        try {
+            let urlObject = new url.URL(this.url);
+            urlObject.search = undefined;
+            urlObject.hash = undefined;
+            dependencyName += " " + urlObject.pathname;
+            remoteDependencyTarget = urlObject.hostname;
+            if (urlObject.port) {
+                remoteDependencyTarget += ":" + urlObject.port;
+            }
 
-        let remoteDependencyTarget = urlObject.hostname;
-
-        if (urlObject.port) {
-            remoteDependencyTarget += ":" + urlObject.port;
         }
-
+        catch (ex) { // Invalid URL
+        }
         if (this.correlationId) {
             remoteDependencyType = Contracts.RemoteDependencyDataConstants.TYPE_AI;
             if (this.correlationId !== CorrelationIdManager.correlationIdPrefix) {
@@ -113,15 +115,21 @@ class HttpDependencyParser extends RequestParser {
         if (typeof options === 'string') {
             if (options.indexOf("http://") === 0 || options.indexOf("https://") === 0) {
                 // protocol exists, parse normally
-                options = new url.URL(options);
+                try {
+                    options = new url.URL(options);
+                }
+                catch (ex) { }
             } else {
                 // protocol not found, insert http/https where appropriate
-                const parsed = new url.URL("http://" + options);
-                if (parsed.port === "443") {
-                    options = new url.URL("https://" + options);
-                } else {
-                    options = new url.URL("http://" + options);
+                try {
+                    const parsed = new url.URL("http://" + options);
+                    if (parsed.port === "443") {
+                        options = new url.URL("https://" + options);
+                    } else {
+                        options = new url.URL("http://" + options);
+                    }
                 }
+                catch (ex) { }
             }
         } else if (options && typeof url.URL === 'function' && options instanceof url.URL) {
             return url.format(options);
@@ -140,9 +148,12 @@ class HttpDependencyParser extends RequestParser {
         // so create them from the path, if path was specified
         if (options.path && options.host) {
             // need to force a protocol to make parameter valid - base url is required when input is a relative url
-            const parsedQuery = new url.URL(options.path, 'http://' + options.host + options.path);
-            options.pathname = parsedQuery.pathname;
-            options.search = parsedQuery.search;
+            try {
+                const parsedQuery = new url.URL(options.path, 'http://' + options.host + options.path);
+                options.pathname = parsedQuery.pathname;
+                options.search = parsedQuery.search;
+            }
+            catch (ex) { }
         }
 
         // Similarly, url.format ignores hostname and port if host is specified,
@@ -153,11 +164,14 @@ class HttpDependencyParser extends RequestParser {
         if (options.host && options.port) {
             // Force a protocol so it will parse the host as the host, not path.
             // It is discarded and not used, so it doesn't matter if it doesn't match
-            const parsedHost = new url.URL(`http://${options.host}`);
-            if (!parsedHost.port && options.port) {
-                options.hostname = options.host;
-                delete options.host;
+            try {
+                const parsedHost = new url.URL(`http://${options.host}`);
+                if (!parsedHost.port && options.port) {
+                    options.hostname = options.host;
+                    delete options.host;
+                }
             }
+            catch (ex) { }
         }
 
         // Mix in default values used by http.request and others

AutoCollection/HttpRequestParser.ts

@@ -66,9 +66,17 @@ class HttpRequestParser extends RequestParser {
     }
 
     public getRequestTelemetry(baseTelemetry?: Contracts.Telemetry): Contracts.RequestTelemetry {
+
+        let name = this.method;
+        try {
+            name += " " + new url.URL(this.url).pathname;
+        }
+        catch (ex) { // Invalid URL
+        }
+
         var requestTelemetry: Contracts.RequestTelemetry & Contracts.Identified = {
             id: this.requestId,
-            name: this.method + " " + new url.URL(this.url).pathname,
+            name: name,
             url: this.url,
             /*
             See https://github.com/microsoft/ApplicationInsights-dotnet-server/blob/25d695e6a906fbe977f67be3966d25dbf1c50a79/Src/Web/Web.Shared.Net/RequestTrackingTelemetryModule.cs#L250
@@ -136,7 +144,20 @@ class HttpRequestParser extends RequestParser {
     }
 
     public getOperationName(tags: { [key: string]: string }) {
-        return tags[HttpRequestParser.keys.operationName] || this.method + " " + new url.URL(this.url).pathname;
+        if(tags[HttpRequestParser.keys.operationName]){
+            return tags[HttpRequestParser.keys.operationName];
+        }
+        let pathName = "";
+        try {
+            pathName = new url.URL(this.url).pathname;
+        }
+        catch (ex) { // Invalid URL
+        }
+        let operationName = this.method;
+        if (pathName) {
+            operationName += " " + pathName;
+        }
+        return operationName;
     }
 
     public getRequestId() {
@@ -169,11 +190,15 @@ class HttpRequestParser extends RequestParser {
         var protocol = (encrypted || request.headers["x-forwarded-proto"] == "https") ? "https" : "http";
 
         var baseUrl = protocol + '://' + request.headers.host + '/';
-        var requestUrl = new url.URL(request.url, baseUrl);
-
-        var pathName = requestUrl.pathname;
-        var search = requestUrl.search;
 
+        var pathName = "";
+        var search = "";
+        try {
+            var requestUrl = new url.URL(request.url, baseUrl);
+            pathName = requestUrl.pathname;
+            search = requestUrl.search;
+        }
+        catch (ex) { }
         var absoluteUrl = url.format({
             protocol: protocol,
             host: request.headers.host,