hoard | js lib for storing time series data | Time Series Database library

We are using Google PubSub in a 'spiky' fashion where we publish millions of small messages (< 10k) in a short time (~ 10 mins), spin up 2k GKE pods with 10 worker threads each that use synchronous pull and acknowledge PubSub service calls to work through the associated subscription (with a 10 minute acknowledgement deadline). The Stack Driver graph for the subscription backlog will show a spike to 10M messages and then a downward slope to 0 in around 30 minutes (see below).
We noticed an increase of message re-delivery as the size of these backlogs grew from 1M to 10M from below 1% to beyond 10% for certain hours.

Coming from the GAE Task Pull queue world, we assumed that a worker would "lease" a message by pulling a message from the PubSub subscription where, starting at the time of pull, a worker would have 10 minutes to acknowledge to message. What appears to be happening however, after adding logging (see below for example of a re-published message), is that it is not the time from pull to ack that matters, but the time from publishing the message to acknowledgement.

Is this the right understanding of PubSub acknowledgement deadline, and subsequent redelivery behavior?

If so, should we be making sure the subscription's message backlog should only grow to a size that worker threads are able to process and acknowledge within the time configured for the subscription's acknowledgement deadline to get re-delivery rates to < 0.1% on average? We can probably have the publisher apply some sort of back-pressure based on the subscription backlog size although the GAE Pull Task Queue leasing behavior seems more intuitive.

Also, the wording in https://cloud.google.com/pubsub/docs/subscriber#push-subscription, under "Pull subscription": "The subscribing application explicitly calls the pull method, which requests messages for delivery" seems to imply that the acknowledgment timeout starts after the client pull call returns a given message?

Note: we use the Python PubSub API (google-cloud-pubsub), although not the default streaming behavior as this caused "message hoarding" as described in the PubSub docs given the large amount of small messages we publish. Instead we call subscriber_client.pull and acknowledge (which seems thin wrappers around the PubSub service API calls)

I'm trying to find a way to have enemies track the player in my 2d game (pygame) but not clump up

Currently, when I shoot at them, the bullet collides into and damages all of the enemies that are clumped. I would like it to be a hoard but spread out just enough to where I can't hit every single enemy at once

It looks like this

Here's a gif of them clumping

I'm not sure how I would get the individual values of the enemies' positions so I can move them when they collide or how I should move them

This is what I currently have for the enemies to track the player:

For a Discord bot, I currently have a command that displays info for our DnD sessions:

.

The data is stored in a dndinfo.json file thats looks like this:

In my project I have, each of the card values displayed on the screen they are looped over from JSON using ngFor. The desired goal is when a user clicks on a card it displays just the information about that card from the JSON while just showing the content in my div with an *ngIf. I have an animation created to fade in a mask where I want the content displayed. Currently if you click on the card it just shows the array of thumbnails. I'm not getting any errors or anything to go on. I've tirelessly searched for answers on how to accomplish showing an individual key on a click. I need the Card image, name, and description displayed for a single card at a time. I feel like I've hit a road block and am not Googling the correct description. Please let me know if I need to further clarify. Thank you for any direction you can offer.

I have a websocket server that hoards memory during days, till the point that Kubernetes eventually kills it. We monitor it using prometheous-net.

I would like to continue writing to an existing text file in my StringBuilder instead of replacing it with a new file.

Reason: To have ongoing logging to file from the datatable and clear it during the process to prevent hoarding up a big amount of memory if the program runs for a long time.

Is it possible?

Below is my current code which replaces with a new text file.

So, I am implementing a genetic algorithm for TSP in Python. To calculate the next generation, I implement this function:

I'm investigating a memory leak via a WinDbg DMP file. I've found that there are many instances of AmazeType on the heap, and although it is an excellent type, there are way too many in existence. I'd like to know who is hoarding them.

!gcroot-ing AmazeType leads me to a "ref counted handle". This makes sense, as the list of awesome type is stored in a property of a COM object instance, via a COM Callable Wrapper.

I am using Kubernetes in Google Cloud (GKE).

I have an application that is hoarding memory I need to take a process dump as indicated here. Kubernetes is going to kill the pod when it gets to the 512Mb of RAM.

So I connect to the pod