heartbeat | Ruby script to test your server for the TLS Heartbleed | TLS library

Please upgrade to version 6.2.4. I fixed a bug that could have caused what you report here.

_{NOTE: the RabbitMQ team monitors the rabbitmq-users mailing list and only sometimes answers questions on StackOverflow.}

I came across a similar problem with the script returning a "Closed" status.

After some tests, I found the script fails when there is no TTY (as is the case if you use tools like ansible)

You should use the 'batch mode' included in karaf client script, so your command would become:

Browsers do not support headers for websockets, therefore the bearer token has to be added as query string parameter. We hit the maximum length for URLs due to the length of our bearer token. We could shorten our token or use a reference token, see also: https://github.com/aspnet/SignalR/issues/1266

Hope this helps others as well.

Several errors in your code, although the idea behind it is almost good. You should use any available tool in async as possible. Some of the needed/desired changes:

• Use tokio::time::sleep because it is async, otherwise the call is blocking
• Use an async version of mutex (the one from futures crate for example)
• Use some kind of generic error handling (anyhow would help)

First, the SQLALCHEMY_DATABASE_URI in database.py should match the user, password and database name suplied in Your docker-compose.yaml. Ensure that You are running docker-compose up with correct environ. In Your case, the environ for docker-compose up should be:

Same problem here. Tried different settings but with no solution.

Workaround: Downgrade RabbitMQ to 3.8. After downgrading there were no connection errors anymore. So, I think it must have something to do with different behavior of v3.9.

Each proxy contract for a Chainlink Price Feed can have multiple underlying aggregator contracts, with one of them being set as the 'active' one at any given instance. Ie whenever the Chainlink Labs team deploys new versions of the aggregator, they update the proxy contract to set the current aggregator version to be the new one, and all new price data starts getting written to the new aggregator.

Based on this, if you want historical price data for a proxy contract/price pair from the last couple weeks or so, you'd need to go to the current aggregator for the proxy contract, then get the current round info (including timestamp), then go back in aggregator rounds in a loop until you get to a round that is less than your search parameter timestamp.

To find the current aggregator contract address for a proxy contract, you can call the aggregator getter function in the proxy contract.

The phase ID can be thought of as an incrementing ID number that the proxy contract uses to identify each aggregator as it gets added to the proxy, so the first one is 1, second is 2 etc. To find out what the current phase ID is of the current aggregator, you can use the phaseId getter function in the proxy contract.

Aggregator round IDs start from 1 and increase by 1 each time. Eg you can use the aggregator latestRound getter function to find the last round that it stored, and then start from that number as an input parameter to getRoundData, and then reduce the number by one and loop through until you reach your point in time.

Unlike Aggregator round IDs, proxy round IDs are those big really long numbers like 36893488147419113293, and are actually just a derived value based on the aggregator phase ID and the aggregator round ID. This is done to ensure the proxy round IDs are always increasing in value, and that there will never be any overlap between the same rounds across different aggregators, eg round 5000 from aggregator with phase ID 1 should have a lower proxy round ID that round 5000 from aggregator with phase ID 2

In Solidity you can easily replicate the proxy round ID derived value with the following formula, passing in the phase ID of the aggregator and the aggregator round ID

In my case, since I had set a timeout of 1,500 milliseconds on the future and because of the slower CPU clock speed of the misbehaving machine, the class was not fully initialised when the timeout occurred. Turns out, OkHttp is more or less the culprit, it takes more than 5 seconds to inistalise the client on the given machine.

All in all, I am no longer applying any timeout on the first try of the connection test to give OkHttp enough time to initialise itself.

Note that this would not solve the problem if the initialisation of the HTTPClient was to fail at a different point in the application lifecycle. But since the first try of the connection test is the first place to call into HTTPClient, this is the only place where it can be initialised.

There are quite a few gaps in the code posted, but I attempted to replicate and in doing so ended up refactoring a bit.

This version seems pretty robust, with the actual call to SendAsync wrapped in an adapter class.

I accept this doesn't necessarily answer the question directly, but in the absence of being able to replicate your problem exactly, offers an alternative way of structuring the code that may eliminate the problem.