fetch(request, isFallback = false, parentSpan = null) {
        if (!isFallback) {
            this.emit('start');
        }
        const url = isFallback
            ? this.attributes.fallbackUrl
            : this.attributes.url;

        const spanOptions = parentSpan ? { childOf: parentSpan } : {};
        const span = tracer.startSpan('fetch_fragment', spanOptions);

        const {
            id,
            primary,
            async: isAsync,
            public: isPublic,
            timeout
        } = this.attributes;

        span.addTags({
            [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
            [Tags.HTTP_URL]: url,
            fallback: isFallback,
            public: isPublic,
            async: isAsync,
            id: id || 'unnamed',
            primary,
            timeout
        });

        this.requestFragment(url, this.attributes, request, span).then(
            res => this.onResponse(res, isFallback, span),
            err => {
                if (!isFallback) {
                    if (this.attributes.fallbackUrl) {
                        this.emit('fallback', err);
                        this.fetch(request, true, span);
                    } else {
                        span.setTag(Tags.ERROR, true);
                        span.log({ message: err.message });
                        this.emit('error', err);
                        this.stream.end();
                    }
                } else {
                    span.setTag(Tags.ERROR, true);
                    span.log({ message: err.message });
                    this.stream.end();
                }
                span.finish();
            }
        );
        // Async fragments are piped later on the page
        if (isAsync) {
            return Buffer.from(
                `<script data-pipe>${this.pipeInstanceName}.placeholder(${this
                    .index})</script>`
            );
        }
        return this.stream;
    }
Handles fetching the fragment
@param {object} request - HTTP request stream
@param {boolean} isFallback - decides between fragment and fallback URL
@param {object} parentSpan - opentracing Span that will be the parent of the current operation
@returns {object} Fragment response streams in case of synchronous fragment or buffer in case of async fragment