constructor()

in extensions/applicationinsights-dependencies-js/src/ajaxRecord.ts [241:350]
93 lines of code
24 McCabe index (conditional complexity)

    constructor(traceID: string, spanID: string, logger: IDiagnosticLogger) {
        let self = this;
        let _logger: IDiagnosticLogger = logger;
        let strResponseText = "responseText";

        // Assigning the initial/default values within the constructor to avoid typescript from creating a bunch of
        // this.XXXX = null
        self.perfMark = null;
        self.completed = false;
        self.requestHeadersSize = null;
        self.requestHeaders = null;
        self.responseReceivingDuration = null;
        self.callbackDuration = null;
        self.ajaxTotalDuration = null;
        self.aborted = 0;
        self.pageUrl = null;
        self.requestUrl = null;
        self.requestSize = 0;
        self.method = null;
        self.status = null;
        self.requestSentTime = null;
        self.responseStartedTime = null;
        self.responseFinishedTime = null;
        self.callbackFinishedTime = null;
        self.endTime = null;
        self.xhrMonitoringState = new XHRMonitoringState();
        self.clientFailure = 0;

        self.traceID = traceID;
        self.spanID = spanID;

        dynamicProto(ajaxRecord, self, (self) => {
            self.getAbsoluteUrl= () => {
                return self.requestUrl ? urlGetAbsoluteUrl(self.requestUrl) : null;
            }
        
            self.getPathName = () => {
                return self.requestUrl ? dataSanitizeUrl(_logger, urlGetCompleteUrl(self.method, self.requestUrl)) : null;
            }
        
            self.CreateTrackItem = (ajaxType:string, enableRequestHeaderTracking:boolean, getResponse:() => IAjaxRecordResponse):IDependencyTelemetry => {
                // round to 3 decimal points
                self.ajaxTotalDuration = Math.round(dateTimeUtilsDuration(self.requestSentTime, self.responseFinishedTime) * 1000) / 1000;
                if (self.ajaxTotalDuration < 0) {
                    return null;
                }
        
                let dependency = {
                    id: "|" + self.traceID + "." + self.spanID,
                    target: self.getAbsoluteUrl(),
                    name: self.getPathName(),
                    type: ajaxType,
                    startTime: null,
                    duration: self.ajaxTotalDuration,
                    success: (+(self.status)) >= 200 && (+(self.status)) < 400,
                    responseCode: (+(self.status)),
                    method: self.method,
                    [strProperties]: { HttpMethod: self.method }
                } as IDependencyTelemetry;

                if (self.requestSentTime) {
                    // Set the correct dependency start time
                    dependency.startTime = new Date();
                    dependency.startTime.setTime(self.requestSentTime);
                }
        
                // Add Ajax perf details if available
                _populatePerfData(self, dependency);
        
                if (enableRequestHeaderTracking) {
                    if (objKeys(self.requestHeaders).length > 0) {
                        dependency[strProperties] = dependency[strProperties] || {};
                        dependency[strProperties].requestHeaders = self.requestHeaders;
                    }
                }
        
                if (getResponse) {
                    let response:IAjaxRecordResponse = getResponse();
                    if (response) {
        
                        // enrich dependency target with correlation context from the server
                        const correlationContext = response.correlationContext;
                        if (correlationContext) {
                            dependency.correlationContext = /* dependency.target + " | " + */ correlationContext;
                        }
        
                        if (response.headerMap) {
                            if (objKeys(response.headerMap).length > 0) {
                                dependency[strProperties] = dependency[strProperties] || {};
                                dependency[strProperties].responseHeaders = response.headerMap;
                            }
                        }
        
                        if (self.errorStatusText && self.status >= 400) {
                            const responseType = response.type;
                            dependency[strProperties] = dependency[strProperties] || {};
                            if (responseType === "" || responseType === "text") {
                                dependency[strProperties][strResponseText] = response[strResponseText] ? response.statusText + " - " + response[strResponseText] : response.statusText;
                            }
                            if (responseType === "json") {
                                dependency[strProperties][strResponseText] = response.response ? response.statusText + " - " + JSON.stringify(response.response) : response.statusText;
                            }
                        }
                    }
                }
        
                return dependency;
            }
        });
    }