function createDependencyData()

in AutoCollection/diagnostic-channel/SpanParser.ts [106:208]
96 lines of code
30 McCabe index (conditional complexity)

function createDependencyData(span: ReadableSpan): Contracts.DependencyTelemetry {
    const remoteDependency: Contracts.DependencyTelemetry = {
        name: span.name,
        success: span.status.code != SpanStatusCode.ERROR,
        resultCode: "0",
        duration: 0,
        data: "",
        dependencyTypeName: ""
    };
    if (span.kind === SpanKind.PRODUCER) {
        remoteDependency.dependencyTypeName = Constants.DependencyTypeName.QueueMessage;
    }
    if (span.kind === SpanKind.INTERNAL && span.parentSpanId) {
        remoteDependency.dependencyTypeName = Constants.DependencyTypeName.InProc;
    }

    const httpMethod = span.attributes[SemanticAttributes.HTTP_METHOD];
    const dbSystem = span.attributes[SemanticAttributes.DB_SYSTEM];
    const rpcSystem = span.attributes[SemanticAttributes.RPC_SYSTEM];
    // HTTP Dependency
    if (httpMethod) {
        remoteDependency.dependencyTypeName = Constants.DependencyTypeName.Http;
        const httpUrl = span.attributes[SemanticAttributes.HTTP_URL];
        if (httpUrl) {
            var pathName = "";
            try {
                let dependencyUrl = new URL(String(httpUrl));
                pathName = dependencyUrl.pathname;
            }
            catch (ex) { }
            remoteDependency.name = `${httpMethod} ${pathName}`;
        }
        remoteDependency.data = getUrl(span);
        const httpStatusCode = span.attributes[SemanticAttributes.HTTP_STATUS_CODE];
        if (httpStatusCode) {
            remoteDependency.resultCode = String(httpStatusCode);
        }
        let target = getDependencyTarget(span);
        if (target) {
            try {
                // Remove default port
                let portRegex = new RegExp(/(https?)(:\/\/.*)(:\d+)(\S*)/);
                let res = portRegex.exec(target);
                if (res != null) {
                    let protocol = res[1];
                    let port = res[3];
                    if ((protocol == "https" && port == ":443") || (protocol == "http" && port == ":80")) {
                        // Drop port
                        target = res[1] + res[2] + res[4];
                    }
                }
            } catch (error) { }
            remoteDependency.target = `${target}`;
        }
    }
    // DB Dependency
    else if (dbSystem) {
        // TODO: Remove special logic when Azure UX supports OpenTelemetry dbSystem
        if (String(dbSystem) === DbSystemValues.MYSQL) {
            remoteDependency.dependencyTypeName = "mysql";
        } else if (String(dbSystem) === DbSystemValues.POSTGRESQL) {
            remoteDependency.dependencyTypeName = "postgresql";
        } else if (String(dbSystem) === DbSystemValues.MONGODB) {
            remoteDependency.dependencyTypeName = "mongodb";
        } else if (String(dbSystem) === DbSystemValues.REDIS) {
            remoteDependency.dependencyTypeName = "redis";
        } else if (isSqlDB(String(dbSystem))) {
            remoteDependency.dependencyTypeName = "SQL";
        } else {
            remoteDependency.dependencyTypeName = String(dbSystem);
        }
        const dbStatement = span.attributes[SemanticAttributes.DB_STATEMENT];
        const dbOperation = span.attributes[SemanticAttributes.DB_OPERATION];
        if (dbStatement) {
            remoteDependency.data = String(dbStatement);
        }
        else if (dbOperation) {
            remoteDependency.data = String(dbOperation);
        }
        let target = getDependencyTarget(span);
        const dbName = span.attributes[SemanticAttributes.DB_NAME];
        if (target) {
            remoteDependency.target = dbName ? `${target}|${dbName}` : `${target}`;
        } else {
            remoteDependency.target = dbName ? `${dbName}` : `${dbSystem}`;
        }
    }
    // grpc Dependency
    else if (rpcSystem) {
        remoteDependency.dependencyTypeName = Constants.DependencyTypeName.Grpc;
        const grpcStatusCode = span.attributes[SemanticAttributes.RPC_GRPC_STATUS_CODE];
        if (grpcStatusCode) {
            remoteDependency.resultCode = String(grpcStatusCode);
        }
        let target = getDependencyTarget(span);
        if (target) {
            remoteDependency.target = `${target}`;
        } else if (rpcSystem) {
            remoteDependency.target = String(rpcSystem);
        }
    }
    return remoteDependency;
}