highlight VS hyperdx

[2] https://app.highlight.io/error-tags

[2] https://github.com/highlight/highlight/tree/main

We have an SDK request here: https://github.com/highlight/highlight/issues/4225

We don't have a particular leaning towards javascript, but haven't gotten to PHP yet. We're definitely open to contributors, but otherwise, we can hopefully get to this in the coming months.

Hi Hacker News! We’re Jay and Vadim from Highlight.io (https://highlight.io). We’re building a truly open source [1] observability platform for modern web applications. We posted some of our tools to HN in recent months [2][3]. Today, we’re excited to formally launch the project, share more about where we’re going, and of course, poll the community for some feedback.

A bit of background: Vadim and I have worked at quite a few startups at this point, and a recurring challenge we’ve faced was tracing usability issues on the frontend to downstream errors and logs on the server. Understanding the real reason behind customer issues was always a chaotic juggling of multiple tools. With the rise of "frontend-forward" frameworks such as NextJS, which blur the boundary between the client and server, the complexity of tracing these issues is only growing.

This is where Highlight.io comes in: our product bridges the gap between client and server to give you a holistic view of your entire application.

At its core, Highlight.io has three main “products”: Session Replay, Error Monitoring, and Logging. The novelty here is not in each product but in how they are connected. For example, in Highlight.io it’s very easy to click from a given error to the associated user session where it is thrown [4], and from a given error, you can easily inspect all of the logs that fired leading up to it. Ensuring that all of our products work together seamlessly with little to no effort is a core principle of our product strategy. If you’re using a common framework [5], for example, we’ll automatically link your frontend sessions with backend errors and logs. No agents, configuring facets, or anything else, It just works.

We depend on several open source projects that help us move quickly. OpenTelemetry (OTEL) [6] is one of them, which helps us with maintainability, i.e. for every language that we support, we only maintain a thin wrapper around its respective OTEL SDK. OTEL is also a great way to enable the community to contribute, and we’re already seeing traction in this space (ie. an open source contributor built a wrapper for a Java SDK [7]).

rrweb [8] is another project we leverage heavily for our session replay product. It drives our ability to record and replay the DOM to visualize user flows in the frontend. We’ve had the privilege to work closely with the rrweb team to ship improvements, and we’re now actively sponsoring the project [9].

ClickHouse [10] has recently become a loved database on our team, as we historically used Opensearch for search-heavy workloads and started to hit growing pains with ingest throughput. We recently rolled it out for our logging product [3] and plan to replace our sessions and errors (and upcoming tracing work) with the database as well.

From a business perspective, Highlight.io is open source under the Apache 2.0 license, and we make money with our hosted product [11]. For the hosted product, you can set billing caps for each offering and we don’t charge for seats. At this point, we have 100+ companies paying for our product (some of which are large enterprises), and thousands of sole developers use Highlight.io every week.

On our roadmap [12] for the future includes metrics, tracing, release management and more. We also are launching several updates this week on our launch week page [13].

Overall, we’re excited to be sharing Highlight.io with the world, and Vadim and I are particularly excited to get some feedback from the HN community. Please give us a test-drive at https://app.highlight.io and let us know what you think. We would love to learn about what you wish you had in an observability product as well as any other experiences and ideas in this space. We look forward to hearing from you!

https://gitlab.com/hyperlink-academy/app https://github.com/highlight/highlight https://github.com/calcom/cal.com https://github.com/Nutlope/roomGPT

I'd be curious to hear how this compares to

https://qryn.metrico.in

and

https://github.com/highlight/highlight

(There are some interesting comparisons/comments vs signoiz in sibling threads).

We only scratched the surface of vanilla-extract here, so check out the documentation if you’re interested in learning more. We’ll continue to share about how we are leveraging it to build the Highlight design system, and all our code is open source if you’re interested in exploring our usage more. All the code for the examples in this article are also available for anyone to fork and play around with as well.

Hi HN, Mike and Warren here! We’ve been building an open source local-dev-friendly mode for HyperDX (hyperdx.io). It's a single Docker container that lets you view logs, metrics, and traces for local development in a similar way you can use them for production (live tail, filter/correlate logs & spans, build charts, flamegraph, etc.) Basically, imagine you can run Datadog in a single container for local development. We does this by spinning up an OpenTelemetry collector, Clickhouse DB and HyperDX UI all in a single container - it only takes a few seconds to start and lets you start live tailing your local logs and traces immediately (and graph metrics of course).

README (w/ demo gif): https://github.com/hyperdxio/hyperdx/blob/main/LOCAL.md

We started building local mode as it became one of our most loved [1] community issue after sharing HyperDX. It made sense - as we constantly use HyperDX to debug our own issues locally, and have found it to be a huge productivity boost for things like…

1. Tailing multiple container logs (and grepping/isolating them) without a ton of different terminal splits open at the same time.

2. Be able to sensibly view structured logs and correlated traces to debug local issues (because you’re using structured logging and tracing right?) instead of adding ad-hoc console statements that print out exactly what I could’ve gotten from tracing.

3. Testing telemetry are actually emitting/correlating as expected, before shipping it all the way out to prod and realizing I accidentally created a very expensive high-cardinality metric or a span that has the wrong properties.

We spent some time packaging & tuning our existing OSS stack to run in a single container with less memory/space requirements by staring at `dive` to slim down the image and applied incantations from documentation until memory usage improved. Additionally we removed a few non-local-friendly things like authentication requirements and extraneous services.

It still has all the goodness you’d want - so you can full text search your logs/traces, live tail all your events, view spans correlated with logs (and vice versa), create dashboards based on logs, metrics, traces, and is fully OpenTelemetry compatible - just point your Otel SDK/collector to http://localhost:4318 (or 4317 for the grpc folks) and you’re already good to go.

I’m excited to share what we’ve been working on and would love to hear your feedback and opinions!

Spin up the container yourself to try it out:

docker run -p 8000:8000 -p 4318:4318 -p 4317:4317 -p 8080:8080 -p 8002:8002 hyperdx/hyperdx-local

Main Open Source Repo: https://github.com/hyperdxio/hyperdx

Hosted Demo (in case you want to play around in a cloud sandbox instead): https://api.hyperdx.io/login/demo

HyperDX Landing Page: https://hyperdx.io

[1]: https://github.com/hyperdxio/hyperdx/issues/7

ClickHouse also excels at storing and querying semi-structured data, like event logs. Previously, many engineering teams used Elasticsearch in a similar niche to ClickHouse, building applications like Kibana. Increasingly, developers are choosing ClickHouse over Elasticsearch for its unparalleled performance characteristics. For example, our friends at hyperdx.io are using ClickHouse to build an open-source OpenTelemetry provider!

HyperDX

Biased as a founder in the space [1] but I think with OpenTelemetry + OSS extensible observability tooling, the holy grail of one tool is more realizable than ever.

Vendor lock in with Otel now is hopefully a thing of the past - but now that more obs solutions are going open source, hopefully it's not necessarily true that one tool would be mediocre over all use cases (since DD and the likes are inherently limited by their own engineering teams, vs OSS products can have community/customer contributions to improve the surface area over time on top of the core maintainer's work).

[1] https://github.com/hyperdxio/hyperdx

HyperDX (YC S22) | Founding Engineer | SF Bay Area HQ | REMOTE

We're building an open source, dev friendly observability tool (think Datadog, but something developers actually love to use and companies can actually afford).

We're in the intersection of needing to build rock solid infrastructure ingesting TBs of data, searching it incredibly quickly and scalably, and layering on top a buttery smooth DX from our language-specific SDKs, APIs and web app.

We're super early and hiring our first founding engineer. We already have a cloud product customers pay for and love, loads of runway regardless of the wider economy, 5k+ Github stars weeks after our OSS launch, and tons of hard technical problems.

The vast majority of our work is open source, so you can get a sense of what you'd be working with here: https://github.com/hyperdxio/hyperdx

Our job listing is here as well: https://www.ycombinator.com/companies/hyperdx/jobs/zFXTbzl-f...

Come by our discord as well if you just want to talk shop: https://discord.gg/FErRRKU78j

I'm Mike, one of the cofounders. If you love shipping quickly and want to help us build from the ground up an open source developer tool (that devs won't hate when they're on-call), let me know! mike [at] hyperdx.io

Oh huh! What would you do with span start independent of stops?

A tangent on logcat - local observability to me is a really intriguing area, I think there's a story of Otel for local as well if someone can build a good enough local DX for consuming them (we've been told a number of times about this https://github.com/hyperdxio/hyperdx/issues/7 as an example)

Hi HN, Mike and Warren here! We’ve been building HyperDX (hyperdx.io). HyperDX allows you to easily search and correlate logs, traces, metrics (alpha), and session replays all in one place. For example, if a user reports a bug “this button doesn’t work," an engineer can play back what the user was doing in their browser and trace API calls back to the backend logs for that specific request, all from a single view. Github Repo: https://github.com/hyperdxio/hyperdx

We're building the OSS equivalent when it comes to the observability side of Splunk/DD, on Clickhouse naturally of course but believe in the same end goal of lowering cost via separation of compute and storage.

https://github.com/hyperdxio/hyperdx