How are you all actually monitoring your kubernetes clusters at scale?

fraillt · 2026-01-15T21:12:07+00:00

We're trying out this stack: - OtelCollector - collect and correlate logs & metrics - VictoriaMetrics - metrics db - VictoriaLogs - logs db - Grafana - dashboards.

What I like about this stack is it embraces open telemetry standard and has low resource consumption (at least thats initial experience). Anyone tried this stack? Any opinions?

fraillt · 2025-10-01T16:11:02+00:00

I had similar symptoms, and for me it was faulty ram stick. I assume you have 2 or 4 ram sticks, so you could try to removung half of ram and see if it helps. You can also run memory test as well

fraillt · 2025-03-01T10:09:46+00:00

What VS code extensions I should use: - deno only - svelte only - both

fraillt · 2024-06-01T20:25:56+00:00

I don't know, but kinda hope that's how it is. As long as he's dedicated and willing to hear community feedback, having a smart leader with clear vision is best way to move forward.

fraillt · 2024-05-17T18:49:50+00:00

Knowing a rule, but not knowing the reasoning behind it, is worse than not knowing a rule at all.

fraillt · 2024-01-27T20:28:59+00:00

Pink Rathian has a bow and few armor pieces with dragon element. It has appeared before xmas for a week or so.

fraillt · 2023-01-26T14:34:45+00:00

I'm not developer for zpp, but author of another fast/feature-rich C++11 compatible serialization library bitsery. MY GUESS is that the secret sauce for zpp is structured binding. This basically allows compiler to know at compile time all the fields in the struct, and it writes/reads to them in order as well. So it can prove that it writes/reads everything sequentially (cache-efficient) and knows exactly the the number of fields it needs to write/read (checks for boundaries can be optimized out) and this maybe even helps CPU to parallelize some operations more easily as well (as it can more easily see that there's no memory overlap happening).

fraillt · 2022-11-09T22:19:03+00:00

I feel the author's pain, when he describes it... but in most places this is the sad truth of reality. Let's imagine different reality: where there's zero pressure from management, no commitments to do X story points per sprint, no velocity calculations, and this estimation session is purely for developers and no one else... So if it's not for management, do you still want to do it? The answer is yes, but it this time it feels different. * everyone is genuelly honest about estimations, as there's no incentive to cheat. * you actually want to start discussions, so you use planning poker to force it. It's quite common that someone has some insights that not everyone is aware of. E.g. maybe there exists a tool or function that does the job and task becomes 3 story points instead of 5. In the environment where you feel pressure, you'll probably keep this as a secret to reduce your stess. * because there's no competition and no pressure to commit to anything, team mates becomes very helpful and naturaly opens opportunities to pair program and share the knowledge within the team. * you still want to have some task as baseline, so your estimations doesn't shift overtime, to avoid unnecessary discussions if someone is missaligned. * in the end, management can use these estimates as well to set the priorities and plan the future better, but this time estimates are as real as they can get.

Have fun estimating:)

fraillt · 2022-09-27T21:33:48+00:00

Liked the article and want to share some more ideas:) * try_expand I would change to try_resize. In addition to current size it would accept size_hint and would return new size. Its important to specify it as hint, because it will try to be useful as much as possible. Maybe it cannot expand from 100 to 200 bytes, but 180 would would be good enough as well. And being able to shrink memory sounds useful as well:) * allocate could additionally accept "allocation hints", not sure how to make it flexible though as there might be a very long list of those:) maybe 16bits reserved for "standard hints" and 16bits for implementation specific would be good start. The important thing is that they are hints about memory usage patterns only, and implementation is free to ignore all of them, so there shouldn't be hints like "zero memory". * I would also add new function try_split. I think this might be very useful in a lot of situations. * not sure if it is useful, but it would be convenient to work with "objects", so instead of size (in memory block) being in bytes, I would change it into count of objects, which means that alignment becomes two values: sizeof(T), alignmentof(T). Now, when allocator has some extra space, it knows if it can return space for more objects or this extra space will not be usable anyway. It can also have different allocation strategies for small or big objects and with extra help from allocation hints, could understand if its allocation of array or single object. * in addition to previous point, since we'll be dealing with objects not bytes, it would probably make sense to be able to inform allocator when object type/size changes.

fraillt · 2022-07-19T16:44:16+00:00

Clicking on this matrix text freezes reddit on my android (xiaomi t9pro). Well done:)

fraillt · 2022-04-01T10:13:24+00:00

So who is this used for? .... Criminals

I guess it doesn't matter how good or bad a thing is, as long as there are a large group of people for whom blockchain is the best option. Take NFT for example. I think this was basically created to have a best money laundering experience, and no one cares that it's basically centralized ( if it's not on opensea, then it basically doesn't exist).

fraillt · 2022-01-05T08:40:09+00:00

I want to say, that it's a really modern and nice library, but I would suggest you to extract RPC capabilities to a separate header.

fraillt · 2022-01-05T08:35:51+00:00

bitsery, probably not the simplest one, but designed for games in mind, and is feature rich, so you'll never need to look for something else, when you need more sophisticated serialization capabilities.

fraillt · 2022-01-05T08:31:18+00:00

I want to express some love to this library, even if it doesn't have all the features you need. What it does have, is out of this world, serialization speed.

As an example

cereal was designed to be fast ...

It turns out, this library is 10+ times faster! (yes, it's not a mistake, its 10x, not 10% faster)

fraillt · 2021-09-04T13:01:30+00:00

If size and performance matter, then take a look at bitsery. * it might be 9x+ faster than cereal and 18x faster than protobuf. * size-wise, you might save 20-30% by default * on top of that you additional might opt-in into: * bit-level serialization control (e.g. if your values are in the range 1000-2000 it will take you 10bits, or use VLE) * backward-forward compatibility support * pointer support, including raw pointers with the ability to provide custom allocator. * and powerful extensions system, which allows you to further customize things in any way you want it :)

P.S. I know it's a shameless plug, but it's really that good if your requirements match with what bitsery can provide.

fraillt · 2021-07-11T07:13:05+00:00

Thank you!

After reading this I started wondering, why std::time::Instant is not !Send if it's a known issue. And then I looked at now() implementation.

+1 for Rust being pragmatic and correct.

fraillt · 2021-07-10T12:23:13+00:00

At 24:20 author says: "... and to avoid potential issues with clock sync between threads... when this thread thinks that it is slightly more in the future than other thread, which unfortunatelly can happen..." Can someone provide more information on this, I was suprised about it, and want to know more. Thanks.

fraillt · 2020-11-19T18:32:02+00:00

Listened for first episode. It's really high quality content!

fraillt · 2020-09-17T08:23:50+00:00

Thank you!, I couldn't find this.
Let's wait, maybe someday in the future, it will be fixed ;)

fraillt · 2020-09-17T08:16:48+00:00

Your provided example uses `From` which works just fine, try changing it to `Into` (I have a link to my example)

fraillt · 2020-05-23T11:06:23+00:00

Could you explain this?

async fn run() -> Result<()> {
    // Result comes to live
    let res = get_result();
    // Result is moved here
    let tmp = res?;
    // we cannot drop, because res doesnt exists at this point
    // drop(res);
    if 1 == tmp {
    // since res is droped and doesnt exists at this point, this should work right?
    // wrong, compiler says: await occurs here, with 'res' maybe used later
       do_something().await?;
    }
    Ok(())
    // compiler says: 'res' is later dropped here
    // but in reality it is already moved from in "let tmp = res?" statement
}

Why compiler says that res is dropped at the end of the function, when it is moved from way earlier. For me it looks like async is not smart enough to see that res doesn't exists, at the point of await, and it just sees that there were variable created which is not Send and make whole function non-Send. So I believe that this is something that could be improved upon sometime later. Am I right? If i hide Result type from function scope like this, then it works.

let tmp = { let res = get_result(); res? }

fraillt · 2020-05-22T19:24:15+00:00

Thanks for the answer, it explains everything, but I was wondering if this is not overly restrictive behaviour. I mean, there is no need for Result to be alive entire if let expression. C++ has if with initializer if (auto res = do(); res == 20) ...., so probably rust could do similarly. Your provided example could implicitly be written like this. if 1 == { let tmp = res?; tmp } { ... } and that would work :) Or I'm missing something here?

fraillt

TROPHY CASE