const BinaryCacheStore::Stats & BinaryCacheStore::getStats()
{
    return stats;
}

    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count();

        % std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count());

        % duration);

    if (!fileExists(narInfo.url)) upsertFile(narInfo.url, narXz);

    if (!fileExists(narInfo.url)) {
        stats.narWrite++;
        upsertFile(narInfo.url, narXz);
    } else
        stats.narWriteAverted++;
    stats.narWriteBytes += nar.size();
    stats.narWriteCompressedBytes += narXz.size();
    stats.narWriteCompressionTimeMs += duration;

    stats.narInfoWrite++;

    stats.narInfoRead++;

    stats.narRead++;
    stats.narReadCompressedBytes += nar.size();

    stats.narReadBytes += nar.size();

#include <atomic>

    struct Stats
    {
        std::atomic<uint64_t> narInfoRead{0};
        std::atomic<uint64_t> narInfoWrite{0};
        std::atomic<uint64_t> narRead{0};
        std::atomic<uint64_t> narReadBytes{0};
        std::atomic<uint64_t> narReadCompressedBytes{0};
        std::atomic<uint64_t> narWrite{0};
        std::atomic<uint64_t> narWriteAverted{0};
        std::atomic<uint64_t> narWriteBytes{0};
        std::atomic<uint64_t> narWriteCompressedBytes{0};
        std::atomic<uint64_t> narWriteCompressionTimeMs{0};
    };

    const Stats & getStats();

    Stats stats;

#if 0
    auto store = make_ref<LocalBinaryCacheStore>(getLocalStore(),
        "/home/eelco/Misc/Keys/test.nixos.org/secret",
        "/home/eelco/Misc/Keys/test.nixos.org/public",
        "/tmp/binary-cache");
#endif
    auto store = std::make_shared<S3BinaryCacheStore>(
        []() { return openStore(); },
        "/home/eelco/Misc/Keys/test.nixos.org/secret",
        "/home/eelco/Misc/Keys/test.nixos.org/public",
        "nix-test-cache-3");;
    store->init();
    _destStore = store;

        root.attr("bytesSent"); out << bytesSent;
        root.attr("bytesReceived"); out << bytesReceived;

        root.attr("bytesSent", bytesSent);
        root.attr("bytesReceived", bytesReceived);

            root.attr("avgStepTime"); out << (float) totalStepTime / nrStepsDone;
            root.attr("avgStepBuildTime"); out << (float) totalStepBuildTime / nrStepsDone;

            root.attr("avgStepTime", (float) totalStepTime / nrStepsDone);
            root.attr("avgStepBuildTime", (float) totalStepBuildTime / nrStepsDone);

                    nested2.attr("avgStepTime"); out << (float) s->totalStepTime / s->nrStepsDone;
                    nested2.attr("avgStepBuildTime"); out << (float) s->totalStepBuildTime / s->nrStepsDone;

                    nested2.attr("avgStepTime", (float) s->totalStepTime / s->nrStepsDone);
                    nested2.attr("avgStepBuildTime", (float) s->totalStepBuildTime / s->nrStepsDone);

                nested2.attr("shareUsed"); out << jobset.second->shareUsed();

                nested2.attr("shareUsed", jobset.second->shareUsed());

        auto store = dynamic_cast<S3BinaryCacheStore *>(&*getDestStore());
        if (store) {
            root.attr("store");
            JSONObject nested(out);
            auto & stats = store->getStats();
            nested.attr("narInfoRead", stats.narInfoRead);
            nested.attr("narInfoWrite", stats.narInfoWrite);
            nested.attr("narRead", stats.narRead);
            nested.attr("narReadBytes", stats.narReadBytes);
            nested.attr("narReadCompressedBytes", stats.narReadCompressedBytes);
            nested.attr("narWrite", stats.narWrite);
            nested.attr("narWriteAverted", stats.narWriteAverted);
            nested.attr("narWriteBytes", stats.narWriteBytes);
            nested.attr("narWriteCompressedBytes", stats.narWriteCompressedBytes);
            nested.attr("narWriteCompressionTimeMs", stats.narWriteCompressionTimeMs);
            nested.attr("narCompressionSavings",
                stats.narWriteBytes
                ? 1.0 - (double) stats.narWriteCompressedBytes / stats.narWriteBytes
                : 0.0);
            nested.attr("narCompressionSpeed", // MiB/s
                stats.narWriteCompressionTimeMs
                ? (double) stats.narWriteBytes / stats.narWriteCompressionTimeMs * 1000.0 / (1024.0 * 1024.0)
                : 0.0);
            auto s3Store = dynamic_cast<S3BinaryCacheStore *>(&*store);
            if (s3Store) {
                nested.attr("s3");
                JSONObject nested2(out);
                auto & s3Stats = s3Store->getS3Stats();
                nested2.attr("put", s3Stats.put);
                nested2.attr("putBytes", s3Stats.putBytes);
                nested2.attr("putTimeMs", s3Stats.putTimeMs);
                nested2.attr("putSpeed",
                    s3Stats.putTimeMs
                    ? (double) s3Stats.putBytes / s3Stats.putTimeMs * 1000.0 / (1024.0 * 1024.0)
                    : 0.0);
                nested2.attr("get", s3Stats.get);
                nested2.attr("getBytes", s3Stats.getBytes);
                nested2.attr("getTimeMs", s3Stats.getTimeMs);
                nested2.attr("getSpeed",
                    s3Stats.getTimeMs
                    ? (double) s3Stats.getBytes / s3Stats.getTimeMs * 1000.0 / (1024.0 * 1024.0)
                    : 0.0);
                nested2.attr("head", s3Stats.head);
                nested2.attr("costDollarApprox",
                    (s3Stats.get + s3Stats.head) / 10000.0 * 0.004
                    + s3Stats.put / 1000.0 * 0.005 +
                    + s3Stats.getBytes / (1024.0 * 1024.0 * 1024.0) * 0.09);
            }
        }

#if 0
    auto store = make_ref<LocalBinaryCacheStore>(getLocalStore(),
        "/home/eelco/Misc/Keys/test.nixos.org/secret",
        "/home/eelco/Misc/Keys/test.nixos.org/public",
        "/tmp/binary-cache");
#endif
    auto store = std::make_shared<S3BinaryCacheStore>(
        []() { return openStore(); },
        "/home/eelco/Misc/Keys/test.nixos.org/secret",
        "/home/eelco/Misc/Keys/test.nixos.org/public",
        "nix-test-cache-3");;
    store->init();
    _destStore = store;

}
const S3BinaryCacheStore::Stats & S3BinaryCacheStore::getS3Stats()
{
    return stats;

    stats.head++;

    stats.put++;
    stats.putBytes += data.size();

    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count();

        % bucketName % path
        % data.size()
        % std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count());

        % bucketName % path % data.size() % duration);
    stats.putTimeMs += duration;

    stats.get++;

    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count();

        % bucketName % path
        % res.size()
        % std::chrono::duration_cast<std::chrono::milliseconds>(now2 - now1).count());

        % bucketName % path % res.size() % duration);
    stats.getBytes += res.size();
    stats.getTimeMs += duration;

#include <atomic>

    struct Stats
    {
        std::atomic<uint64_t> put{0};
        std::atomic<uint64_t> putBytes{0};
        std::atomic<uint64_t> putTimeMs{0};
        std::atomic<uint64_t> get{0};
        std::atomic<uint64_t> getBytes{0};
        std::atomic<uint64_t> getTimeMs{0};
        std::atomic<uint64_t> head{0};
    };
    const Stats & getS3Stats();

    Stats stats;