fasthttp | Tuned for high performance | Performance Testing library

Use a single engine with groups:

DB is nil, because var DB=database.DB runs before database.DB is initialized.

Use database.DB directly.

You can use net/http/pprof for profiling.
fasthttp provides custom implementation for the same. You can use that same as the net/http/pprof.

To use this, register the handler as:

Base User classes need an attribute abstract = True to not be instantiated. https://docs.locust.io/en/stable/api.html#locust.User.abstract

I dont think you can do the same with load shape classes, but you can use class attributes (which you can manipulate in your locustfile after importing it)

Like removing Rps class and instead just doing

For big file uploads browsers send a Expect: 100-continue header to ask the server if it's ok for them to continue with the upload. You could use https://godoc.org/github.com/valyala/fasthttp#Server.ContinueHandler to check for permissions and either allow or reject the upload.

Fasthttp will always read the full response before calling a handler. This allows for a more performant API with less allocations.

The big answer: both are correct (as in they work just fine), just different.

Per the docs, a fasthttp.Client is safe for concurrent use so sharing one instance is fine. It may run into concurrent connection limits but that might not be an issue.

The second example does have some overhead and will not be able to reuse connections or parameters, but again this could be a use case where it does not matter (if I only perform two operations, saving on the overhead might not be worth optimizing for).

For the second part of the question:

• c is already a *fasthttp.Client, so there's not need to take its address (&fasthttp.Client returns a pointer to a new fasthttp.Client)
• wg is a plain sync.WaitGroup so the address must be taken

I believe upgrade should be a string:

Based on your question I think this is already clear to you, but just in case: Sessions aren't started on the client, they are started on the server. The server checks to see if a specific cookie exists; if it does it resumes the session that the cookie identifies; if it doesn't it creates a new session and sends the identifier back to the client as a cookie. All the client needs to do is send the correct cookie to the server.

So, you need to read and write cookies. The fasthttp.Client.Post() interface doesn't allow you to do that. So instead of that nice interface, things become rather ugly.

You need to ask fasthttp for both a Request and Response object before you do the request. Once you've done the initial request, you need to either look all cookies, or read out a specific cookie. You can now use those values for your next request.

I've written a short example of how you would do this.