Слайды моего доклада “Advanced debugging techniques in different environments” на Kyiv Go Meetup July 2019:

- демо проект link
- слайды файлом link
- slideshare link

Вопросы пиши в личку: @a_soldatenko

Note #9 Когда лучше использовать именнованые параметры в функциях, определеных в интерфейсах?

Ели нам попадается такой код, то не совсем понятно что такое str или int O_O:

type runner interface {
 run(context.Context, string, int)
}

Сразу же последует PR с чем-то вроде такого:

2c2
<  run(context.Context, string, int)
---
>  run(ctx context.Context, service string, instances int)
4d3
<

Так намного лучше :)

Но иногда есть более спорный кейс, в котором называть не объязательно:

type Enroller interface {
  Enroll(*User, *Course) error
}

// P.S.
func main(){println("не забываем, что код пишется, еще и для наших коллеги, а не только для того, чтобы его можно было запустить на проде!")}

🍺

Note #11: Go 2 и числовые литералы

Tl;dr в Go версии 2 собираются добавить некоторые изменения, которые затронут числовые литералы. Так это и так все знают: подумали Вы?
Давайте посмотрим, что же уже сейчас есть в go репо в главной ветке (master branch):

$ git clone git@github.com:golang/go.git
$ cd go/src && ./all.bash
$ go version devel +eee07a8e68 Wed Aug 21 15:20:00 2019 +0000 darwin/amd64

Один из самых заметных для меня это конечно _ в цифрах).

Небольшой примерчик:

package main

func main() {
  println("1_200_000 -> ", 1_200_000)
  println("3.1415_9265 -> ", 3.1415_9265)
  println("0b0110_1101_1101_0010 -> ",0b0110_1101_1101_0010)
  // println("0___ -> ", 0___) invalid example from discussion
  // println(" 0__.0__e-0__ -> ",0__.0__e-0__) invalid example from discussion
  // println("1__2", 1__2) invalid 
}

Итак:

$ go version
$ go1.12.7 darwin/amd64
$ go run main.go
# command-line-arguments
./main.go:4:28: syntax error: unexpected _200_000, expecting comma or )
./main.go:5:35: syntax error: unexpected _9265, expecting comma or )
./main.go:6:39: syntax error: unexpected b0110_1101_1101_0010, expecting comma or )

Oops 😬


Попытка номер 2:

./go version 
devel +eee07a8e68 Wed Aug 21 15:20:00 2019 +0000 darwin/amd64
./go run main.go
1_200_000 ->  1200000
3.1415_9265 ->  +3.141593e+000
0b0110_1101_1101_0010 ->  28114

Go 1.13RC1:

go get golang.org/dl/go1.13rc1
go1.13rc1 run main.go
1_200_000 ->  1200000
3.1415_9265 ->  +3.141593e+000
0b0110_1101_1101_0010 ->  28114

🎉🎉🎉🎉

P.S. Не совсем понятно почему это вроде как должно быть в Go2, а попало в Go 1.13 … наверное я что-то упустил, пойду читать GIthub…

[1] https://go.googlesource.com/proposal/+/master/design/19308-number-literals.md

Note #12: defer statements in infinite loops

Длинный стек отложенных вызовов может занимать много памяти, как Вы уже догадались такой код будет стремительно течь 💦:

$ cat main.go

package main

func g()

func f() {
  for {
    defer g()
  }
}

func main() {
  f()
}

Отловить данную проблему поможет статический анализатор:

deferlint:

go vet -vettool=$(which deferlint) .
# github.com/andriisoldatenko/golang_for_two
./main.go:10:4: defer in loop found "defer g()"

либо staticcheck

staticcheck
main.go:10:4: defers in this infinite loop will never run (SA5003)

Иногда данная ситуация абсолютно валидная, поэтому staticcheck пытается найти циклы без условий или брейков, чтобы отметить такой кейс, это помогает бороться с ложными срабатываниями.

Кстати, deferlint - отличный пример, как написать свой линтер[1].
Исправить данную ситуацию возможно, обернув defer в анонимную функцию, чтобы гарантированно ваша отложенная функция была вызвана вовремя.

func f() {
  for {
    func(){
      defer g()
    }()
  }
}

Потенциально, любой цикл, а особенно бесконечный, может служить причиной утечки памяти. defer следует гарантированно выполнять сразу же после того, как мы освободили ресурс, который нам уже больше не нужен. А иногда - это может происходить в цикле.

Links:
[1] Если вдруг вы пропустили статью о том, как написать свой линтер использую go/analysis, то вот https://arslan.io/2019/06/13/using-go-analysis-to-write-a-custom-linter/

Note #13: go doc with colors

Если вы используете go doc, для быстрого доступа к go документации, есть интересная идея как это все разукрасить:

func main() {
  args := []string{"doc"}
  args = append(args, os.Args[1:]...)
  cmd := exec.Command("go", args...)
  cmd.Env = os.Environ()

  output, _ := cmd.CombinedOutput()

  stdout := colorable.NewColorableStdout()
  err := quick.Highlight(stdout, string(output),
    "go", "terminal256", style)

  stdout.Write([]byte("\033[0m\n"))
}

Код очень простой и не странно, что принимает те же параметры что и go doc :trollface:, как описал автор :)

Link: https://github.com/inancgumus/godocc

Установить можно так:

go get -u github.com/inancgumus/godocc

GODOCC_STYLE=monokai godocc time Unix

Note #14 argument reusing in fmt.Printf

Бывает необходимость напечатать несколько раз одно и тоже значение или значение и тип:

fmt.Printf("Num: %d %d\n", 2, 2)
// or
fmt.Printf("Num: %d %T\n", 2, 2)

Это легко переписать, используя индексы аргументов:

fmt.Printf("Num: %d\n", 42)
fmt.Printf("Num: %d %[1]d %[1]d %[2]d %[2]d", 2, 3)
}

more details: https://golang.org/pkg/fmt/

Note #15 Go и зарезервированные ключевые слова

Ключевые слова в Go можно переопределять, НО никогда не стоит так делать!
Такой код, как Вы уже догадались, вполне себе валидный код в Go:

package main

import (
  "fmt"
)

func main() {
        const iota = iota
        fmt.Println(iota, iota, iota)
}

И мы получим в результате:😱: 0 0 0.

Как следствие:

const (
  a = iota
  b
  c
)
fmt.Println(a, b, c)

0 0 0

И staticcheck или go vet ничего нам не сказали :(

И в конце, чтобы запутать своих коллег еще сильнее, возможно написать так:

type int struct{}

func main() {
  var i int
  i++
  fmt.Println(i)
}

Компилятор подскажет ошибку:
invalid operation: i++ (non-numeric type int) o_O

P.S. SyntaxError: invalid syntax было бы лучше :)

Links:
[1] https://golang.org/ref/spec#Predeclared_identifiers
[2] https://play.golang.org/p/6OW0pJMvgQk

Note # 17 Скомпилируется или нет? Или игра с ссылками.

Есть пример программы, которая скорее всего не скомпилируется?! :)

Program:

package main

import (
  "fmt"
)

var g *int

func f(p *****int) { g = ****p }

func main() {
  var i int
  j := &i
  k := &j
  l := &k
  m := &l
  f(&m)
  fmt.Printf("%T\n", &m)
  fmt.Printf("%T", f)
}

Итак перед тем как копировать код и запускать на play.golang.org, я решил немного освежить как же работают ссылки в Go. Есть небольшой пример:

func main() {
  var i = 42
  var j = &i
  fmt.Println("i = ", i)
  fmt.Println("j = ", j)
  fmt.Println("*j = ", *j)
}

Думаю тут все и так понятно:

// Output
i =  100
j =  0xc0000160b8
*j =  100

Проблема лишь в том, что пока, я не приблизились к нашему первоначальному примеру ни на шаг.
И тут я вспомнил, то факт, что ссылка, может ссылаться на любой тип, в том числе, и быть ссылкой на ссылку, т.е. можно написать **p (dereferencing a pointer to pointer).

func main() {
  var i = 42 
  var p = &i
  var pp = &p
  fmt.Println("pp = ", pp)
  // Dereferencing a pointer to pointer
  fmt.Println("*pp = ", *pp)
  fmt.Println("**pp = ", **pp)
}
pp =  0xc0000bc010
*pp =  0xc0000c2000
**pp =  42

P.S. я думаю теперь вы догадались, какой правильный ответ.
Goto Program

Note #19 Reduce sturct size (maligned) 📄

Недавно много говорили, о том что одна и та же структура (type struct), с разными типами полей и с разным порядком, может занимать разное кол-во памяти в зависимости от того, как расположить в памяти компьютера с учетом всех отступов. Более детально прочитать можно в вики [1], почему именно так происходит.

Хотелось бы, чтобы компилятор самостоятельно делал такие оптимизации.

Возьмем структура A:

$ cat main.go
// A is my struct
type A struct {
    a bool    // 1 byte
    b float64 // 8 bytes
    c int32   // 4 bytes
}

Хорошо что есть отличный линтер[2], который напомнит нам, что можно что-то улучшить:

$ golangci-lint run --enable=maligned main.go
main.go:4:8: struct of size 24 bytes could be of size 16 bytes (maligned)
type A struct {
       ^

либо

go get github.com/mdempsky/maligned
$ maligned .
/Users/andrii/work/golang_for_two/main.go:4:8: struct of size 24 could be 16

Links:
- https://en.wikipedia.org/wiki/Data_structure_alignment
- https://github.com/mdempsky/maligned

Note #21 Contributing to the os Package 💬

Недавно начал смотреть доклады c GopherCon 2019. Понравился доклад от молодого и перспективного разработчика из Лондона Оливера Стэнбома,
который полностью соответсвует моим критериям идеального доклада:
- реальная история из жизни о найденном баге;
- сложные будни и куча emailов на тему как же пофиксить этот баг на всех ОС;
- завести PR получить заветные +2 (перед этим подумать зачем я вообще брался за этот баг)
- вуаля баг пофикшен и попал в релиз go1.12 🎉🎉🎉

Сам баг довольно простой:

func main() {
        tmpDir, err := ioutil.TempDir("", "")
        if err != nil {
                panic(err)
        }
        err = createVeryLongFilePath(tmpDir)
        if err != nil {
                panic(err)
        }
        err = os.RemoveAll(tmpDir)
        if err != nil {
                panic(err)
        }
}
os: RemoveAll fails for long file paths

Оригинальный фикс в проекте у Оливера занимает 1 экран, но финальный фикс в Go для unix и solaris поместился в +774 -229 добавленных и удаленных строк кода соответсвенно!

P.S.
ссылка на доклад -> https://www.youtube.com/watch?v=cQgpNkKi9aA
🍺

Note #22 Vulnerability Static Analysis for Containers 🛡🐳

Quay.io содержит интересный репорт:

Quay Security Scanner has detected 74 vulnerabilities.
Patches are available for 2 vulnerabilities.
 4 High-level vulnerabilities.

Все это осуществляется с помощью тула clair от CoreOS team - который умеет сканировать ваши докер имеджи на разные CVE уязвимости.

Недавно мне пришлось фиксить такие High severity issues… 🤔

Чтобы запустить clair локально нам понадобится:

1) Свежий дамп с базой данных CVE: тут 2 варианта либо самостоятельно залить дамп в пустую PostgreSQL БД, либо взять готовый имедж PostgreSQL с уже предустановленным дампом, либо накатить последний дамп руками занимает минут 40 :( Но добрый человек все уже сделал за Вас):

docker run -p 5432:5432 -d --name db arminc/clair-db:latest

2) Запустить clair api локально

docker run -p 6060:6060 --link db:postgres -d --name clair arminc/clair-local-scan:latest

3) и установить clair-scanner локально (прочитать тут https://github.com/arminc/clair-scanner)

clair-scanner -r grafana_report.txt --ip=192.168.1.200 grafana/grafana:master
2019/09/02 17:25:16 [INFO] ▶️ Start clair-scanner
2019/09/02 17:25:20 [INFO] ▶️ Server listening on port 9279
2019/09/02 17:25:20 [INFO] ▶️ Analyzing a61298a1d179786c2c176dc6c3e20c2d0cad25582e53a7bbec428fc4370a679e
...
73a18bb7d185e7c6763c97311263a8b773ce0641adb2186f7291702f4ef437bd
2019/09/02 17:25:24 [INFO] ▶️ Image [grafana/grafana:master] contains NO unapproved vulnerabilities

Дальше можно фиксить уязвимости, как правило, просто обновив некоторые библиотеки и вуаля 🎉, возвращаем долг опенсорсу, в виде PRs например в grafana ;)

P.S. Также данные проверки можно добавить к своему CI/CD.
https://ibb.co/XLdPmQQ

Note #24 Go и runtime
Существует много споров на тему Go рантайм и Go пакета runtime. Давайте разберемся с этим вопросом.

C одной стороны в Go есть рантайм, который написан на Go в отличии от Java(написан на С). C точки зрения архитектуры, рантайм - это просто коллекция нескольких уникальных частей, самые важные из которых: сборщик мусора и планировщик горутин (goroutine scheduler).

С другой стороны, Go рантайм также реализует фичи, которые экспортируются наружу c помощью пакета runtime. C помощью пакета runtime можно осуществлять управление сборщиком мусора и выводить различную дебаг информация см (runtime/debug).
Либо вывести сколько памяти занимает ваша программа:

package main

import (
    "runtime"
    "fmt"
    "time"
)

func PrintMememoryStats() {
        var m runtime.MemStats
        // The returned memory allocator statistics are up to date as of the call to ReadMemStats. This is in contrast with a heap profile, which is a snapshot as of the most recently completed garbage collection cycle.
        runtime.ReadMemStats(&m)
        fmt.Printf("Alloc = %v Mb", m.Alloc / 1024 / 1024)
        fmt.Printf(" TotalAlloc = %v Mb", m.TotalAlloc / 1024 / 1024)
        fmt.Printf(" Sys = %v Mb", m.Sys / 1024 / 1024)
        fmt.Printf(" NumGC = %v\n", m.NumGC)
}
func main() {
    PrintMememoryStats()
    var total [][]int

    for i := 0; i<3; i++ {
        array := make([]int, 0, 4200000)
        total = append(total, array)
        PrintMememoryStats()
        time.Sleep(time.Second)
    }
    PrintMememoryStats()
    runtime.GC()
    PrintMememoryStats()
}

Note: Также важно понимать, что Go рантайм не включает в себя виртуальную машину, а код программы на Go компилируется сразу в машинный код, кстати это позволяет нам так легко писать программы, которые легко портируются на разные ОС. Поэтому в контексте Go - когда говорят Go и runtime - это обычно имя пакета, а не виртуальное окружение в котором программа на Go запускается.

Note #26 LEAP year

Часто на собеседованиях в качестве разминки просят написать функцию, которая определяет является ли год высокосным или нет. Также подобную задачу можно найти в онлайн соревнованиях как SPOJ или CodeChef.

Т.е. сигнатура функции выглядит примерно так:

 func IsLeapYear(y int) bool

Так как использование стандартной библиотеки языка обычно не запрещено, то вдруг в голову пришла идея поискать, что там есть, после неудачного поиска по докам пакета time, как и ожидалось ничего подходящего не нашлось, я решил чуток подумать и сделать себе :coffee:

Самое близкое что я нашел было https://golang.org/pkg/time/#Time.YearDay:
> returns the day of the year specified by t, in the range [1,365] for non-leap years, and [1,366] in leap years.

После прочитанного пришла тривиальная идея, создать дату использую номер года и некоторые дефолтные параметры а именно последний день года, что позволит нам использовать метод YearDay, чтобы проверить 31 декабря какой день 365-ый или 366-ой?

 func IsLeapYear(y int) bool {
         year := time.Date(y, time.December, 31, 0, 0, 0, 0, time.Local)
         days := year.YearDay()  
         if days > 365 {
                 return true
         } else {
                 return false
         }
 }

Далее естественно я полез смотреть исходники time.YearDay, и наткнулся на src/time/time.go:1329



func isLeap(year int) bool {
  return year%4 == 0 && (year%100 != 0 || year%400 == 0)
}

Т.е полезная, но не экспортируемая функция isLeap :)
P.S. в качестве упражнения можно реализовать func isLeap(year big.Int) bool.
P.P.S Отличный пример можно найти в доках math/big как вычислить фибоначчи используя арифметику больших чисел.

Links:
SPOJ - https://www.spoj.com/problems/ORTL1P07/
CodeChef - https://www.codechef.com/problems/LEAPY
алгоритм - https://en.wikipedia.org/wiki/Leap_year#Algorithm