$ kubectl debug node/default-pool-3mrgkk --image debian -it --profile=sysadmin --share-processes=true -- bash

apt update
apt install bpfcc-tools/stable
ln -s /host/lib/modules/ /lib/modules 
ln -s /host/usr/src/* /usr/src/ 
mount -t debugfs debugfs /sys/kernel/debug 
mount -t tracefs tracefs /sys/kernel/tracing 
cachetop-bpfcc

postgres=# alter subscription "pgo_lr_sub_l1_myapp_875a65d6" enable;
ERROR:  subscription "pgo_lr_sub_l1_myapp_875a65d6" does not exist

postgres=# select * from pg_subscription;
-[ RECORD 1 ]-------+----------------------------------------------------------------------------------------------------------------------------------
oid                 | 24664
subdbid             | 16502
subskiplsn          | 0/0
subname             | pgo_lr_sub_l1_myapp_875a65d6
subowner            | 10
subenabled          | f
subbinary           | f
substream           | p
subtwophasestate    | d
subdisableonerr     | t
subpasswordrequired | t
subrunasowner       | f
subfailover         | f
subconninfo         | user=logicalrepl host='cluster1-primary.pg-26033.svc' port=5432 sslmode='verify-ca' sslrootcert='/pgconf/tls/ca.crt' dbname=myapp
subslotname         | pgo_lr_slot_l1_myapp_875a65d6
subsynccommit       | off
subpublications     | {pgo_lr_pub_l1_myapp_875a65d6}
suborigin           | any

Because pg_subscription is a shared catalog, so you can see every subscription from any database. You need run ALTER SUBSCRIPTION in the database referenced in subdbid.

postgres=# select datname from pg_database where oid = 16502;
 datname
---------
 myapp
(1 row)
 
postgres=# \c myapp
You are now connected to database "myapp" as user "postgres".
 
myapp=# alter subscription "pgo_lr_sub_l1_myapp_875a65d6" enable;
ALTER SUBSCRIPTION

DDL breaks logical replication because they are not replicated and apply workers start to fail. Rather than reseeding, you can just execute the same DDL on logical replica and re-enable subscription.

test=# ALTER SYSTEM SET default_transaction_read_only TO off;
ALTER SYSTEM

test=# SELECT pg_reload_conf();
 pg_reload_conf
----------------
 t
(1 row)

test=# alter table t1 add column b int;
ALTER TABLE


test=# ALTER SUBSCRIPTION pgo_lr_sub_logical_test_274c8e45 ENABLE;
ALTER SUBSCRIPTION

test=# select subname, subenabled from pg_subscription;
             subname              | subenabled
----------------------------------+------------
 pgo_lr_sub_logical_test_274c8e45 | t
(1 row)

test=# select * from t1;
   id   |     a      | b
--------+------------+---
 100500 |            |
 100501 |            |
 100502 |            |
 100503 |            |
 100504 |            |
 100505 | new column |
 100506 | a          | 1
(7 rows)

You’ll see an error like:

2026-08-10 15:28:23.867 UTC [427] ERROR:  logical replication target relation "public.t1" is missing replicated column: "a"

There’s no way to check this error except from the log.

pg_stat_subscription_stats.apply_error_count will increase every 5 seconds as the apply worker spawns and fails. Every 5 seconds seems not configurable.

There is an option to disable subscription on errors:

ALTER SUBSCRIPTION ... SET (disable_on_error = true)

With disable_on_error, pg_subscription.subenabled will be set to false if there are any errors.

based on “a shell exclamation mark is not for yelling. be lazy.” by filip roséen. applies to interactive bash, csh, tcsh, zsh — not scripts.

anatomy

![event][:word][:modifier]
    |      |        |
    |      |        '--> modifier    [ :h :t :r :e ... ]
    |      '-----------> which part  [ :0 :$ :* :2-3 ... ]
    '------------------> which line  [ !! !-2 !ssh !?needle? ... ]

! followed directly by : refers to the previous line.

event designators — which line

word designators — which part

example previous line: /path/to/script.sh "hello world" --enable 1337

short forms: !$ = !:$, !* = !:*.

modifiers — transform the part

the four worth memorizing

everyday combos

$ apt install pkg          # permission denied
$ sudo !!                  # rerun with sudo
 
$ mkdir /var/mnt/cache
$ cd !$                    # cd into it
 
$ touch ~/projects/work/awesome.sh
$ cd !$:h                  # cd to its directory
 
$ ssh 10.240.33.109 -p2222 -i ~/.ssh/prod/ed25519
$ ssh 10.240.33.110 !:2*   # same flags, other host
 
$ ffmpeg -i /rec/day.mov !#:2:r.mkv   # reuse arg from current line, swap ext
$ scp !$:r.* example.com:/media

posix fallback: fc

works in any posix shell (except truly minimal ones like dash / busybox ash). edits history in $FCEDIT (fallback ed; many shells use $EDITOR).

turning it off / customizing

set +H                 # bash: disable history expansion
setopt nobanghist      # zsh: same
histchars='%^#'        # change trigger chars (event, substitution, comment)

common gotcha: echo "!dlrow olleh" → event not found (double quotes don’t protect !; single quotes do).

package main
 
import "fmt"
 
type Bar struct {
	Bar string
}
 
type Bars []Bar
 
type Foo struct {
	Bars Bars
}
 
func main() {
	f := Foo{Bars: []Bar{{Bar: "ege"}}}
	fmt.Printf("Foo: %+v\n", f)
	for _, e := range f.Bars {
		e.Bar = "gule"
	}
	fmt.Printf("Foo: %+v\n", f)
 
	f = Foo{Bars: []Bar{{Bar: "ege"}}}
	fmt.Printf("Foo: %+v\n", f)
	for i, _ := range f.Bars {
		x := &f.Bars[i]
		x.Bar = "gule"
	}
	fmt.Printf("Foo: %+v\n", f)
}

Foo: {Bars:[{Bar:ege}]}
Foo: {Bars:[{Bar:ege}]}
Foo: {Bars:[{Bar:ege}]}
Foo: {Bars:[{Bar:gule}]}

package main
 
import (
	"fmt"
)
 
// binarySearch performs binary search on a sorted slice.
// It returns the index of target if present, or -1 if not found.
func binarySearch(slice []int, target int) int {
    low := 0
    high := len(slice) - 1
 
    for low <= high {
        mid := low + (high-low)/2
 
        if slice[mid] == target {
            return mid
        }
 
        if slice[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
 
    return -1 // target not found
}
 
func main() {
    slice := []int{2, 3, 4, 10, 40}
    target := 10
    result := binarySearch(slice, target)
    if result != -1 {
        fmt.Printf("Element found at index %d\n", result)
    } else {
        fmt.Println("Element not found in the slice")
    }
}

ticker := time.NewTicker(5 * time.Second)
for range ticker.C {
	log.Println("Hey!")
}

With timeout

ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
 
timeout := time.NewTimer(300 * time.Second)
defer timeout.Stop()
 
for {
	select {
	case <-timeout.C:
		return errors.New("timeout")
	case <-ticker.C:
		// do
	}
}

First Approach:

w := bytes.Buffer{}
w.WriteString(itemType)
w.WriteRune(':')
w.WriteString(clientId)

Second Approach:

l := len(itemType) + len(clientId) + len(id) + 2
buf := make([]byte, 0, l)
w := bytes.NewBuffer(buf)

Key Differences

Memory Allocation:

• The first approach uses bytes.Buffer’s internal 64-byte array for small strings
• The second approach pre-allocates a specific buffer size based on the final string length

Performance Characteristics:

• First approach: 2 allocations (one for buffer structure, one for String() conversion)
• Second approach: 3 allocations (initial slice, buffer structure, and String() conversion)

Use Cases:

• First approach is better for:

  • Small strings that fit within the 64-byte internal buffer
  • When exact size is unknown
  • Simpler code with fewer allocations

• Second approach is better for:

  • Large strings where size is known
  • When you want to control initial capacity
  • Cases where memory efficiency is critical

Buffer in the first approach automatically grows when writing more than 64 bytes.

Internal Buffer Management

Initial State:

• A zero-value bytes.Buffer starts with a small internal array of 64 bytes (smallBufferSize)
• This is an optimization for small strings to avoid initial allocations

Growth Mechanism:

• When writing data, the buffer first tries to grow by reslicing
• If reslicing isn’t possible, it calls the grow() function
• For empty buffers under 64 bytes, it allocates exactly smallBufferSize
• For larger sizes, it doubles the capacity when more space is needed

Growth Algorithm

The buffer grows according to these rules:

1. First attempts to use the internal 64-byte array
2. When that’s exceeded, allocates a new slice with formula:

if c := 2*cap(b.buf) + n; c > 2*cap(b.buf) {
    buf = make([]byte, n, c)
}