Backlog | Backlog : Game database | Video Game library

Ops Agent is looking for credentials and not finding them.

This means you either did not copy the service account to the correct location with the correct file access permissions OR you did not set up the environment variable GOOGLE_APPLICATION_CREDENTIALS correctly with the correct file access permissions.

The agent then checks the metadata service which does not support Google OAuth access tokens (Azure provides MSI credentials if setup)

There are 3 ways to lower costs:

• downscale your job, you will have higher latency but for a lower cost, up to a point where your job crashes because it runs out of memory over time and/or can't catch up with its backlog. Here you need to keep an eye on your metrics to make sure you can react before it's too late
• going further, you can regroup multiple queries into a single job. This job most likely won't be aligned in partitions, so it won't be able to scale linearly (adding SUs is not guaranteed to give you better performance). Same comment as above, plus you need to remember that when you need to scale back up, you probably will have to break down that job into multiple jobs to again be able to scale in a linear fashion
• finally you can auto-pause a job, one way to implement that being explained in the doc you linked. I wrote that doc, and what I meant by that comment is that here again you are taking the risk of overloading the job if it can't run long enough to process the backlog of events. This is a risky proposition for most production scenarios

But if you know what you are doing, and are monitoring closely the appropriate metrics (as explained in the doc), this is definitely something you should explore.

Finally, all of these approaches, including the auto-pause one, will deal with tumbling windows transparently for you.

Update: 2022-03-03 following comments here

Update: 2022-03-04 following comments there

There are 3 time dimensions here:

• When the job is running or not: the wall clock
• When the time window is expected to output results: Tumbling(day,1) -> 00:00AM every day, this is absolute (on the day, on the hour, on the minute...) and independent of the job start time below
• What output you want produced from the job, via the job start time

Let's say you have the job running 24/7 for multiple months, and decide to stop it at noon (12:00PM) on the 1st day of March.

It already has generated an output for the last day of February, at 00:00AM Mar1.

You won't see a difference in output until the following day, 00:00AM Mar2, when you expect to see the daily window of Mar1, but it's not output because the job is stopped.

Let's start the job at 01:00AM Mar2 wall clock time. If you want the missing time window, you should either pick a start time at 'when last stopped' (noon the day before), or a custom time any time before 23:59PM Mar1. What you are driving is the output window you want. Here you are telling ASA you want all the windows from that point onward.

ASA will then reload all the data it needs to generate that window (make sure the event hub has enough retention for that, we don't cache data between restarts in the job): Azure Stream Analytics will automatically look back at the data in the input source. For instance, if you start a job “Now” and if your query uses a 5-minutes Tumbling Window, Azure Stream Analytics will seek data from 5 minutes ago in the input. The first possible output event would have a timestamp equal to or greater than the current time, and ASA guarantees that all input events that may logically contribute to the output has been accounted for.

Try below

I'm reticent to take a stab at answering this for real without knowing what's going on in color_table. My hunch, based on the behavior you're describing is that filter_json_run_all is being forced to wait on a congested DOM manipulation/render pipeline as HTML is being updated to achieve the color-coding for your updated table elements.

I see you're already taking some measures to prevent some of these DOM manipulations from blocking this function's execution (via setTimeout). If color_table isn't already employing a similar strategy, that'd be the first thing I'd focus on refactoring to unclog things here.

It might also be worth throwing these DOM updates for processed events into a simple queue, so that if slow browser behavior creates a rendering backlog, the function actually responsible for invoking pending DOM manipulations can elect to skip outdated render operations to keep the UI acceptably snappy.

Edit: a basic queueing system might involve the following components:

1. The queue, itself (this can be a simple array, it just needs to be accessible to both of the components below).
2. A queue appender, which runs during filter_json_run_all, simply adding objects to the end of the queue representing each DOM manipulation job you plan to complete using color_table or one of your setTimeout` callbacks. These objects should contain the operation to performed (i.e: the function definition, uninvoked), and the parameters for that operation (i.e: the arguments you're passing into each function).
3. A queue runner, which runs on its own interval, and invokes pending DOM manipulation tasks from the front of the queue, removing them as it goes. Since this operation has access to all of the objects in the queue, it can also take steps to optimize/combine similar operations to minimize the amount of repainting it's asking the browser to do before subsequent code can be executed. For example, if you've got several color_table operations that coloring the same cell multiple times, you can simply perform this operation once with the data from the last color_table item in the queue involving that cell. Additionally, you can further optimize your interaction with the DOM by invoking the aggregated DOM manipulation operations, themselves, inside a requestAnimationFrame callback, which will ensure that scheduled reflows/repaints happen only when the browser is ready, and is preferable from a performance perspective to DOM manipulation queueing via setTimeout/setInterval.

I was not able to recreate your issue but I think you should check the way its being handled on the official documentation about using cloud pubsublite.

This is the code I extract and update from Receiving messages sample and It works as intended, it will get the message from the lite-topic and acknowledge to avoid getting it again. if rerun, I will only get the data if there is data to pull. I added the code so you can check if something may differ from your code.

consumer.py

You can use the setVisible function in marker class like this:

I think this should help https://grafana.com/go/observabilitycon/2020/keynote-what-is-observability/ if you go to minute 41. There's an example which is very similar to what you're trying to achieve.

Your query should look something like:

Disclaimer: I never used pyejabberd, so I'll just give you some ideas to investigate.

I see your client attempts to connect to port 5443 with HTTP protocol. Looking at your ejabberd configuration, that has TLS enabled... so maybe it should be HTTPS? Or you can try to set "tls: false" in ejabberd.

Also, what kind of connection method does pyejabberd use to connect to ejabberd? XMPP (port 5222), or XMPP over BOSH (port 5443), or XMPP over WebSocket (port 5443, but a different URL path).

Maybe you should set in pyejabberd port 5222 and protocol xmpp, or something like that.

Check in ejabberd log files, if it receives the connection attempt. Try to login with a well-known XMPP client, so you learn how that looks in ejabberd log files (what messages it shows when login is successful), and compare that with your client.

Your linked list should contain a list of all socket file descriptors for HTTP requests that must be handled. Therefore, each node in your linked list should contain a file descriptor.

What you are currently doing instead is creating a linked list in which every node contains a pointer to a file descriptor. However, every node points to the same file descriptor variable (to clientSock in the function main). Due to this, your linked list is effectively only storing a single file descriptor, which is constantly being overwritten whenever a new HTTP request arrives.

Therefore, you should change the definition of a linked list node, so that every node contains its own file descriptor (instead of a pointer to one):