rss-tools @ ecbe2c093170b8ecb436d4951ce9d0f4ee781334

···
        80
        80
         		go func(w func(context.Context) error) {

      
        81
        81
         			defer a.wg.Done()

      
        82
        82
         			if err := w(ctx); err != nil {

      
        83
        
        -				slog.ErrorContext(ctx, "worker exited with an error", "err", err)

      
        
        83
        +				a.Logger.ErrorContext(ctx, "worker exited with an error", "err", err)

      
        84
        84
         			}

      
        85
        85
         		}(worker)

      
        86
        86
         	}

      ···
        106
        106
         		}()

      
        107
        107
         	}()

      
        108
        108
         

      
        109
        
        -	slog.Info("starting http server", "port", a.Config.Port)

      
        
        109
        +	a.Logger.Info("starting http server", "port", a.Config.Port)

      
        110
        110
         	if err := httpSrv.ListenAndServe(); err != http.ErrServerClosed {

      
        111
        111
         		return err

      
        112
        112
         	}

      

···
        1
        1
         package app

      
        2
        2
         

      
        3
        3
         import (

      
        4
        
        -	"log/slog"

      
        5
        4
         	"net/http"

      
        6
        5
         	"strings"

      
        7
        6
         	"time"

      ···
        24
        23
         		start := time.Now()

      
        25
        24
         		wrapped := wrapResponseWriter(w)

      
        26
        25
         		next.ServeHTTP(wrapped, r)

      
        27
        
        -		slog.Info("http request",

      
        
        26
        +		a.Logger.Info("http request",

      
        28
        27
         			"method", r.Method,

      
        29
        28
         			"status", wrapped.status,

      
        30
        29
         			"path", r.URL.Path,

      

···
        20
        20
         	client    *http.Client

      
        21
        21
         	tg        *TelegramSDK

      
        22
        22
         	allowedID int64

      
        
        23
        +	logger *slog.Logger

      
        23
        24
         }

      
        24
        25
         

      
        25
        26
         func Register(a *app.App) error {

      ···
        39
        40
         		client:    a.Client,

      
        40
        41
         		tg:        NewSDK(a.Client, a.Config.TGToken),

      
        41
        42
         		allowedID: a.Config.TGUserID,

      
        
        43
        +		logger: a.Logger,

      
        42
        44
         	}

      
        43
        45
         

      
        44
        46
         	a.AddWorker(t.worker)

      ···
        76
        78
         	for {

      
        77
        79
         		updates, err := t.tg.GetUpdates(ctx, offset)

      
        78
        80
         		if err != nil {

      
        79
        
        -			slog.ErrorContext(ctx, "getUpdates failed", "err", err)

      
        
        81
        +			t.logger.ErrorContext(ctx, "getUpdates failed", "err", err)

      
        80
        82
         			select {

      
        81
        83
         			case <-ctx.Done():

      
        82
        84
         				return nil

      ···
        87
        89
         

      
        88
        90
         		for _, u := range updates {

      
        89
        91
         			if u.Message != nil && u.Message.From != nil {

      
        90
        
        -				slog.InfoContext(ctx, "message from", "user_id", u.Message.From.ID, "username", u.Message.From.Username, "msg", messageText(u.Message))

      
        
        92
        +				t.logger.InfoContext(ctx, "message from", "user_id", u.Message.From.ID, "username", u.Message.From.Username, "msg", messageText(u.Message))

      
        91
        93
         			}

      
        92
        94
         

      
        93
        95
         			if u.Message == nil || u.Message.From == nil || u.Message.From.ID != t.allowedID {

      ···
        96
        98
         			}

      
        97
        99
         

      
        98
        100
         			if err := t.saveMessage(u.Message); err != nil {

      
        99
        
        -				slog.ErrorContext(ctx, "failed to save message", "err", err)

      
        
        101
        +				t.logger.ErrorContext(ctx, "failed to save message", "err", err)

      
        100
        102
         			}

      
        101
        103
         

      
        102
        104
         			if err := t.tg.SetReaction(ctx, u.Message.From.ID, u.Message.MessageID, "👍"); err != nil {