Skip to content

lesovsky/noisia

Repository files navigation

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 page.

Using Docker

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:

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
  • About grammar issues or typos let me know here.

License

BSD-3. See LICENSE for more details.