seiflotfy

Probably. Being able to point your own agent at the data through something open like MCP is one hedge against that. (Disclosure: I'm CTO at Axiom, and we ship an MCP server.)

I know I am biased (CTO of axiom.co here) but billions is something we deal with and we reached a point where the majority of queries are coming through our mcp server. Cost is not an issue.

I agree with you. agents don't look at dashboards... the future is MCP servers.

may I ask what you use now to send all those logs, metrics and traces?

https://arxiv.org/pdf/2101.01719 ?

lol! gilfoyle -> anton -> son_of_anton -> tsenart -> gilfoyle! the complete cycle

I fail to see how this works with hyperloglog. But will read more

Actually i found zig easier to read than rust… something that i found more appealing!

This is awesome... question though: ```pub fn HyperLogLog(comptime p: u8) type { return struct { dense: [1<<p]u6;

            const Self = @This();
            pub fn init() Self {
                var s = Self{};
                for (s.dense) |*x| x.* = 0;
                return s;
            }
        }
    }```

doesn't this allocate 1<<p upfront though. If yes then the HLL of size 16384 bytes upfront which kinda beats the purpose of having a sparse representation no?

Author here, will publish my vlang take on it in the next couple of days.

Great question (and apologies for the length of the answer)! Through our previous experiences in building services around tsdbs & relying on tsdbs to host monitoring data, we kept hitting the same issues around ingest, retention, and querying capabilities.

Existing solutions, and those architected in a more traditional way than Axiom, would require highly-coordinated nodes running on expensive VMs that would be bound by cpu, memory, and storage depending on your use case:

- Want to store TBs of data for months/years and query any piece of that at any time? Prepare to have expensive SSDs or wait for 'archived' data to swap in from cheaper storage.

- Want to run a query that combines N datasets, calculates aggregations, over TBs of data, and then compare that against data with the time shifted back a week, month, or year? Great, fire up some heavy VMs with enough cpu, memory, and bandwidth to compute all that.

- What if you use case varying greatly in each dimension (how much ingest you'd use, how much storage you'd need, and how heavy your queries would be) across a day, week, or month? You'd have to find a way to adapt to changing requirements or just scale up for the worst case x2 and just pay the $$$.

With Axiom, we had three key goals:

- Hyper-efficient, co-ordination free, schema-less, and index-free ingest (~1.4TB/day on a $5/mo container)

- Cheapest storage for hot, cold, archived and warehoused data: all data is stored in object storage, highly compressed & ready to query. 10 seconds or 10 years old data is the same, already as cheap as possible.

- Serverless querying that can expand from 0 to as-much-as-AWS-will-allow depending on what your query needs + how many of your team are querying at once.

The above was achieved through a lot of trial-and-error, tweaking, testing, and head-scratching, but we're really proud of what we've built. We can run super-fast ad-hoc queries, we've eliminated the need to think about retention, we have live streaming, and we have an incredible query language inspired by Microsoft's Kusto (Splunk users will be familiar!).

We still have a lot I'd like to see done, but I think we really do have something unique :)

CTO here... we built our own homegrown tsdb that works on top of S3. Coordination free ingestion, Serverless querying :D

Leerob and co are fantastic :D The feedback we got from the Vercel team while building the integration was invaluable :D

Also feel free to join our slack for more feedback :D

Sorry had to edit my reply ;)

We are familiar with honeycomb and we also have a honeycomb->axiom multiplexer, so you can use their great tools, to forward to use and compare side by side.

https://github.com/axiomhq/axiom-honeycomb-proxy It's called proxy but its actually a multiplexer ;)

Some things where we are different:

* We don't sample if you push to us directly.

* Our pricing is different (https://www.axiom.co/pricing#calculator)

* We are younger but we built it a bit differently, with object storage being our only storage.

* We have a Kusto(-ish) language (https://play.axiom.co/axiom-play-qf1k/explorer?qid=uqXTzFSTv...)

* We provide a streaming view https://play.axiom.co/axiom-play-qf1k/stream/github-issue-co...

renamed to variance

The beginning of Lockdowns in 2020 is when there was more mention of death than life on HN.