Prometheus: How is the Remote Write API code Path different from the Scrape Code Path

// Line 364
r.Post("/write", api.ready(api.remoteWrite))

// NewWriteHandler creates a http.Handler that accepts remote write requests and
// writes them to the provided appendable.
func NewWriteHandler(logger log.Logger, appendable storage.Appendable) http.Handler {
    return &writeHandler{
        logger: logger,
        appendable: appendable
    }
}

var (
    localStorage = &readyStorage{stats: tsdb.NewDBStats()}
    scraper = &readyScrapeManager{}

    remoteStorage = remote.NewStorage(log.With(logger, "component", "remote"), prometheus.DefaultRegisterer, localStorage.StartTime, localStoragePath, time.Duration(cfg.RemoteFlushDeadline), scraper)

    fanoutStorage = storage.NewFanout(logger, localStorage, remoteStorage)

)


// Line 1287
type readyStorage struct {
    mtx sync.RWMutex
    db storage.Storage
    startTimeMargin int64
    stats *tsdb.DBStats
}

type Appendable interface {
    // Appender returns a new appender for the storage. The implementation
    // can choose whether or not to use the context, for deadlines or to check
    // for errors.
    Appender(ctx context.Context) Appender
}

type Appender interface {

    // Append adds a sample pair for the given series.
    // An optional series reference can be provided to accelerate calls.
    // A series reference number is returned which can be used to add further
    // samples to the given series in the same or later transactions.
    // Returned reference numbers are ephemeral and may be rejected in calls
    // to Append() at any point. Adding the sample via Append() returns a new
    // reference number.

    // If the reference is 0 it must not be used for caching.

    Append(ref SeriesRef, l labels.Labels, t int64, v float64) (SeriesRef, error)
    // Commit submits the collected samples and purges the batch.  If Commit
    // returns a non-nil error, it also rolls back all modifications made in
    // the appender so far, as Rollback would do. In any case, an Appender
    // must not be used anymore after Commit has been called.

    Commit() error

    // Rollback rolls back all modifications made in the appender so far.
    // Appender has to be discarded after rollback.

    Rollback() error

    ExemplarAppender

    HistogramAppender

    MetadataUpdater

}

mainLoop:
    for {
        ...
    }

scrapeCtx, cancel := context.WithTimeout(sl.parentCtx, sl.timeout)
contentType, scrapeErr = sl.scraper.scrape(scrapeCtx, buf)

#... Line 1364
total, added, seriesAdded, appErr = sl.append(app, b, contentType, appendTime)

func (s *targetScraper) scrape(ctx context.Context, w io.Writer) (string, error) {
    if s.req == nil {
        req, err := http.NewRequest("GET", s.URL().String(), nil)
        if err != nil {
            return "", err
        }
        req.Header.Add("Accept", s.acceptHeader)
        req.Header.Add("Accept-Encoding", "gzip")
        req.Header.Set("User-Agent", UserAgent)
        req.Header.Set("X-Prometheus-Scrape-Timeout-Seconds", strconv.FormatFloat(s.timeout.Seconds(), 'f', -1, 64))

        s.req = req
    }

    resp, err := s.client.Do(s.req.WithContext(ctx))
    if err != nil {
        return "", err
    }
    defer func() {
        io.Copy(io.Discard, resp.Body)
        resp.Body.Close()
    }()

    if resp.StatusCode != http.StatusOK {
        return "", errors.Errorf("server returned HTTP status %s", resp.Status)
    }

    if s.bodySizeLimit <= 0 {
        s.bodySizeLimit = math.MaxInt64
    }
    if resp.Header.Get("Content-Encoding") != "gzip" {
        n, err := io.Copy(w, io.LimitReader(resp.Body, s.bodySizeLimit))
        if err != nil {
            return "", err
        }
        if n >= s.bodySizeLimit {
            targetScrapeExceededBodySizeLimit.Inc()
            return "", errBodySizeLimit
        }
        return resp.Header.Get("Content-Type"), nil
    }

    if s.gzipr == nil {
        s.buf = bufio.NewReader(resp.Body)
        s.gzipr, err = gzip.NewReader(s.buf)
        if err != nil {
            return "", err
        }
    } else {
        s.buf.Reset(resp.Body)
        if err = s.gzipr.Reset(s.buf); err != nil {
            return "", err
        }
    }

    n, err := io.Copy(w, io.LimitReader(s.gzipr, s.bodySizeLimit))
    s.gzipr.Close()
    if err != nil {
        return "", err
    }
    if n >= s.bodySizeLimit {
        targetScrapeExceededBodySizeLimit.Inc()
        return "", errBodySizeLimit
    }
    return resp.Header.Get("Content-Type"), nil
}

### For example, this switches on whether or not to append a histogram or just append:
if isHistogram {
       if h != nil {
              ref, err = app.AppendHistogram(ref, lset, t, h)
       }
} else {
          ref, err = app.Append(ref, lset, t, val)
}

// appender returns an appender for ingested samples from the target.
func appender(app storage.Appender, limit int) storage.Appender {
    app = &timeLimitAppender{
        Appender: app,
        maxTime:  timestamp.FromTime(time.Now().Add(maxAheadTime)),
    }

    // The limit is applied after metrics are potentially dropped via relabeling.
    if limit > 0 {
        app = &limitAppender{
            Appender: app,
            limit:    limit,
        }
    }
    return app
}

// Flush implements the Writer interface. This is where actual block writing
// happens. After flush completes, no writes can be done.

func (w *BlockWriter) Flush(ctx context.Context) (ulid.ULID, error) {

    mint := w.head.MinTime()

    // Add +1 millisecond to block maxt because block intervals are half-open: [b.MinTime, b.MaxTime).

    // Because of this block intervals are always +1 than the total samples it includes.

    maxt := w.head.MaxTime() + 1

    level.Info(w.logger).Log("msg", "flushing", "series_count", w.head.NumSeries(), "mint", timestamp.Time(mint), "maxt", timestamp.Time(maxt))

    compactor, err := NewLeveledCompactor(ctx, nil, w.logger []int64{w.blockSize}, chunkenc.NewPool(), nil)

    if err != nil {
        return ulid.ULID{}, errors.Wrap(err, "create leveled compactor")
    }

    id, err := compactor.Write(w.destinationDir, w.head, mint, maxt, nil)

    if err != nil {
        return ulid.ULID{}, errors.Wrap(err, "compactor write")
    }

    return id, nil
}

if _, err = writeMetaFile(c.logger, tmp, meta); err != nil {
    return errors.Wrap(err, "write merged meta")
}

// Create an empty tombstones file.
if _, err := tombstones.WriteFile(c.logger, tmp, tombstones.NewMemTombstones()); err != nil {
    return errors.Wrap(err, "write new tombstones file")
}