leakdice
kafka-go
leakdice | kafka-go | |
---|---|---|
4 | 13 | |
18 | 7,144 | |
- | 1.4% | |
0.0 | 6.7 | |
about 5 years ago | 6 days ago | |
C | Go | |
GNU General Public License v3.0 only | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
leakdice
-
My Rust program (Well, game) is leaking memory, 4MB/s.
Maybe try Leakdice: https://github.com/tialaramex/leakdice in C or rewritten in Rust: https://github.com/tialaramex/leakdice-rust/
-
Twenty Years of Valgrind
In my obviously biased opinion, very specialised, but sometimes exactly what you needed (I have used this in anger maybe 2-3 times in my career since then, which is why I wrote the C version):
https://github.com/tialaramex/leakdice (or https://github.com/tialaramex/leakdice-rust)
Leakdice implements some of Raymond Chen's "The poor manโs way of identifying memory leaks" for you. On Linux at least.
https://bytepointer.com/resources/old_new_thing/20050815_224...
All leakdice does is: You pick a running process which you own, leakdice picks a random heap page belonging to that process and shows you that page as hex + ASCII.
The Raymond Chen article explains why you might ever want to do this.
-
Hunting down a C memory leak in a Go program
(or there's a Rust rewrite https://github.com/tialaramex/leakdice-rust because I was learning Rust)
leakdice is not a clever, sophisticated tool like valgrind, or eBPF programming, but that's fine because this isn't a subtle problem - it's very blatant - and running leakdice takes seconds so if it wasn't helpful you've lost very little time.
Here's what leakdice does: It picks a random heap page of a running process, which you suspect is leaking, and it displays that page as ASCII + hex.
That's all, and that might seem completely useless, unless you either read Raymond Chen's "The Old New Thing" or you paid attention in statistics class.
Because your program is leaking so badly the vast majority of heap pages (leakdice counts any pages which are writable and anonymous) are leaked. Any random heap page, therefore, is probably leaked. Now, if that page is full of zero bytes you don't learn very much, it's just leaking blank pages, hard to diagnose. But most often you're leaking (as was happening here) something with structure, and very often sort of engineer assigned investigating a leak can look at a 4kbyte page of structure and go "Oh, I know what that is" from staring at the output in hex + ASCII.
This isn't a silver bullet, but it's very easy and you can try it in like an hour (not days, or a week) including writing up something like "Alas the leaked pages are empty" which isn't a solution but certainly clarifies future results.
-
`Zig Cc`: A Powerful Drop-In Replacement for GCC/Clang
Right. Even in an entirely safe language you can have leaks, and valgrind is an effective way to find those leaks if you can afford the virtualisation overhead.
If you can't afford the virtualisation overhead, and you need to find leaks you should try what Raymond Chen suggests in "The poor man's way of identifying memory leaks" (not bothering to link since Microsoft will only move it anyway, they have several times since I read it). If you are too lazy to do it by hand, or find the technique works but wish it less manual, this is what Leakdice does:
https://github.com/tialaramex/leakdice
kafka-go
-
book about golang and kafka
There are two main libraries that people use to write clients Confluent Kafka and segment io kafka
-
Klient - a native, statically-compiled, command line client for Kafka
Unlike the standard scripts, and many binary clients, it's a native, statically-compiled, binary. It uses segmentio/go-kafka internally, which means CGO can be disabled during compilation.
-
Is Kafka the Key? The Evolution of Highlight's Ingest
Scaling up our producers/consumers proved to be more cost-effective than adding more CPU/brokers to the Kafka cluster. To accomplish this, we used the segmentio/kafka-go client library which provides an excellent abstraction for interacting with the cluster and will handle data compression completely transparently.
-
Go EventSourcing and CQRS with PostgreSQL, Kafka, MongoDB and ElasticSearch ๐โจ๐ซ
PostgeSQL as event store database Kafka as messages broker gRPC Go implementation of gRPC Jaeger open source, end-to-end distributed tracing Prometheus monitoring and alerting Grafana for to compose observability dashboards with everything from Prometheus MongoDB MongoDB database Elasticsearch Elasticsearch client for Go. Echo web framework Kibana Kibana is data visualization dashboard software for Elasticsearch Migrate for migrations
-
Kafkagosaur - First release
I want to announce the first release of a kafkagosaur, a new Kafka client. It's built using WebAssembly and binds to the kafka-go library. The first release includes functionality to read and write Kafka messages and SASL support.
-
Switching from Celery and Python to Go
Use the Segment Kafka library, not Sarama, itโs much easier to use https://github.com/segmentio/kafka-go
-
I share my authentication server.
Kafaka - kafka-go, Debezium Outbox
-
Hunting down a C memory leak in a Go program
Segment learned quite some time ago that librdkafka-go has problems like these (and doesnโt support Contexts either), so they wrote a pure Go replacement instead. https://github.com/segmentio/kafka-go
-
Go, Kafka and gRPC clean architecture CQRS microservices with Jaeger tracing ๐๐งโ๐ป
In this article let's try to create closer to real world CQRS microservices with tracing and monitoring using: ๐ Kafka as messages broker gRPC Go implementation of gRPC PostgreSQL as database Jaeger open source, end-to-end distributed tracing Prometheus monitoring and alerting Grafana for to compose observability dashboards with everything from Prometheus MongoDB Web and API based SMTP testing Redis Type-safe Redis client for Golang swag Swagger for Go Echo web framework
- confluent-kafka-go or Shopify/sarama
What are some alternatives?
libclang_rt.builtins-wasm32.a - The missing libclang_rt.builtins-wasm32.a file to compile to WebAssembly.
sarama - Sarama is a Go library for Apache Kafka. [Moved to: https://github.com/IBM/sarama]
mevi - A memory visualizer in Rust (ptrace + userfaultfd)
Confluent Kafka Golang Client - Confluent's Apache Kafka Golang client
bytehound - A memory profiler for Linux.
franz-go - franz-go contains a feature complete, pure Go library for interacting with Kafka from 0.8.0 through 3.6+. Producing, consuming, transacting, administrating, etc.
hotspot - The Linux perf GUI for performance analysis.
retry-go - Simple golang library for retry mechanism
heaptrack - A heap memory profiler for Linux
kafka-rust - Rust client for Apache Kafka
cobra - A Commander for modern Go CLI interactions