134 lines
3.0 KiB
Go
134 lines
3.0 KiB
Go
package logs
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"os"
|
|
"os/signal"
|
|
"slices"
|
|
"sync"
|
|
|
|
"github.com/docker/docker/api/types"
|
|
containerTypes "github.com/docker/docker/api/types/container"
|
|
"github.com/docker/docker/api/types/filters"
|
|
"github.com/docker/docker/api/types/swarm"
|
|
dockerClient "github.com/docker/docker/client"
|
|
)
|
|
|
|
type TailOpts struct {
|
|
AppName string
|
|
Services []string
|
|
StdErr bool
|
|
Since string
|
|
Buffer *bytes.Buffer
|
|
ToBuffer bool
|
|
Filters filters.Args
|
|
}
|
|
|
|
// TailLogs gathers logs for the given app with optional service names to be
|
|
// filtered on. These logs can be printed to os.Stdout or gathered to a buffer.
|
|
func TailLogs(
|
|
cl *dockerClient.Client,
|
|
opts TailOpts,
|
|
) error {
|
|
sigintChannel := make(chan os.Signal, 1)
|
|
signal.Notify(sigintChannel, os.Interrupt)
|
|
defer signal.Stop(sigintChannel)
|
|
|
|
f := filters.NewArgs()
|
|
for _, name := range opts.Services {
|
|
f.Add("name", name)
|
|
}
|
|
|
|
services, err := cl.ServiceList(
|
|
context.Background(),
|
|
types.ServiceListOptions{Filters: f},
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
waitCh := make(chan struct{})
|
|
|
|
go func() {
|
|
var wg sync.WaitGroup
|
|
for _, service := range services {
|
|
f := filters.NewArgs()
|
|
f.Add("name", service.Spec.Name)
|
|
|
|
tasks, err := cl.TaskList(context.Background(), types.TaskListOptions{Filters: f})
|
|
if err != nil {
|
|
// TODO
|
|
// return nil
|
|
}
|
|
|
|
if len(tasks) > 0 {
|
|
// Need to sort the tasks by the CreatedAt field in the inverse order.
|
|
// Otherwise they are in the reversed order and not sorted properly.
|
|
slices.SortFunc[[]swarm.Task](tasks, func(t1, t2 swarm.Task) int {
|
|
return int(t2.Meta.CreatedAt.Unix() - t1.Meta.CreatedAt.Unix())
|
|
})
|
|
lastTask := tasks[0].Status
|
|
if lastTask.State != swarm.TaskStateRunning {
|
|
// for _, task := range tasks {
|
|
// TODO
|
|
// return fmt.Errorf("[%s] %s state %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err)
|
|
// }
|
|
}
|
|
}
|
|
|
|
// Collect the logs in a go routine, so the logs from all services are
|
|
// collected in parallel.
|
|
wg.Add(1)
|
|
go func(serviceID string) {
|
|
logs, err := cl.ServiceLogs(context.Background(), serviceID, containerTypes.LogsOptions{
|
|
ShowStderr: true,
|
|
ShowStdout: !opts.StdErr,
|
|
Since: opts.Since,
|
|
Until: "",
|
|
Timestamps: true,
|
|
Follow: true,
|
|
Tail: "50", // TODO: if buf, bump it up!
|
|
Details: false, // TODO: if buf, yes!
|
|
})
|
|
if err != nil {
|
|
// TODO
|
|
// log.Debugf("unable to poll logs: %s", err)
|
|
}
|
|
defer logs.Close()
|
|
|
|
if opts.ToBuffer {
|
|
_, err = io.Copy(opts.Buffer, logs)
|
|
if err != nil && err != io.EOF {
|
|
// TODO
|
|
// log.Debugf("unable to copy buffer: %s", err)
|
|
}
|
|
logs.Close()
|
|
return
|
|
}
|
|
|
|
_, err = io.Copy(os.Stdout, logs)
|
|
if err != nil && err != io.EOF {
|
|
// TODO
|
|
// log.Debugf("unable to copy buffer: %s", err)
|
|
}
|
|
logs.Close()
|
|
|
|
}(service.ID)
|
|
}
|
|
|
|
wg.Wait()
|
|
close(waitCh)
|
|
}()
|
|
|
|
select {
|
|
case <-waitCh:
|
|
return nil
|
|
case <-sigintChannel:
|
|
return nil
|
|
}
|
|
|
|
return nil
|
|
}
|