Skip to content
master
Switch branches/tags
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
cmd
 
 
db
 
 
 
 
 
 
 
 
 
 
log
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Noisia

Harmful workload generator for PostgreSQL.


Supported workloads:

  • idle transactions - active transactions on hot-write tables that do nothing during its lifetime.
  • rollbacks - fake invalid queries that generate errors and increase rollbacks counter.
  • waiting transactions - transactions that locks hot-write tables and then idle, that lead to stuck other transactions.
  • deadlocks - simultaneous transactions where each hold locks that the other transactions wants.
  • 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 on already running workload produced by other applications. This impact might be expressed as performance degradation, transactions 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.