Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/lesovsky/noisia

Harmful workload generator for PostgreSQL
https://github.com/lesovsky/noisia

benchmarking failure-injection postgresql testing

Last synced: about 13 hours ago
JSON representation

Harmful workload generator for PostgreSQL

Awesome Lists containing this project

README

        

# Noisia

**Harmful workload generator for PostgreSQL.**

---

#### Supported workloads:
- `idle transactions` - active transactions on hot-write tables that do nothing during their lifetime.
- `rollbacks` - fake invalid queries that generate errors and increase rollbacks counter.
- `waiting transactions` - transactions that lock hot-write tables and then idle, leading to other transactions getting stuck
- `deadlocks` - simultaneous transactions where each holds locks that the other transactions want.
- `temporary files` - queries that produce on-disk temporary files due to lack of `work_mem`.
- `terminate backends` - terminate random backends (or queries) using `pg_terminate_backend()`, `pg_cancel_backend()`.
- `failed connections` - exhaust all available connections (other clients unable to connect to Postgres).
- `fork connections` - execute single, short query in a dedicated connection (lead to excessive forking of Postgres backends).
- ...see built-in help for more runtime options.

#### Disclaimer

ATTENTION: USE ONLY FOR TESTING PURPOSES, DO NOT EXECUTE NOISIA WITHOUT COMPLETE UNDERSTANDING WHAT YOU REALLY DO, RECKLESS USAGE WILL CAUSE PROBLEMS.

DISCLAIMER: THIS SOFTWARE PROVIDED AS-IS WITH NO CARES AND GUARANTEES RELATED TO YOUR DATABASES. USE AT YOUR OWN RISK.

#### Installation and usage
Check out [releases](https://github.com/lesovsky/noisia/releases) page.

#### Using Docker
```shell script
docker pull lesovsky/noisia:latest
docker run --rm -ti lesovsky/noisia:latest noisia --help
```

#### Using in your own code
You can import `noisia` and use necessary workloads in your code. Always use contexts to avoid infinite run. See tiny example below:

```go
package main

import (
"context"
"fmt"
"github.com/lesovsky/noisia/waitxacts"
"github.com/rs/zerolog"
"log"
"os"
"time"
)

func main() {
config := waitxacts.Config{
Conninfo: "host=127.0.0.1",
Jobs: 2,
LocktimeMin: 5*time.Second,
LocktimeMax: 20*time.Second,
}

logger := zerolog.New(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: time.RFC3339}).Level(zerolog.InfoLevel).With().Timestamp().Logger()

ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second)
defer cancel()

w, err := waitxacts.NewWorkload(config, logger)
if err != nil {
log.Panicln(err)
}

err = w.Run(ctx)
if err != nil {
fmt.Println(err)
}
}
```

#### Workload impact

Running workloads could impact already running workloads produced by other applications. This impact might be expressed as performance degradation, transactions getting stuck, cancelled queries, disconnected clients, etc.

| Workload | Impact? |
| :--- | :---: |
| deadlocks | No |
| failconns | **Yes**: exhaust `max_connections` limit; this leads to other clients are unable to connect to Postgres |
| forkconns | **Yes**: excessive creation of Postgres child processes; potentially might lead to `max_connections` exhaustion |
| idlexacts | **Yes**: might lead to tables and indexes bloat |
| rollbacks | No |
| tempfiles | **Yes**: might increase storage utilization and degrade storage performance |
| terminate | **Yes**: already established database connections could be terminated accidentally |
| waitxacts | **Yes**: locks heavy-write tables; this leads to blocking concurrently executed queries |

#### Contribution
- PR's are welcome.
- Ideas could be proposed [here](https://github.com/lesovsky/noisia/discussions)
- About grammar issues or typos let me know [here](https://github.com/lesovsky/noisia/discussions/8).

#### License
BSD-3. See [LICENSE](LICENSE) for more details.