scrabble-game/platform/telegram/cmd/telegram/main.go

// Command telegram is the Telegram platform side-service (the "connector"). It is
// the only component holding the bot token: it runs the Bot API long-poll loop
// (Mini App launch + /start deep-links) and serves the connector gRPC API
// (pkg/proto/telegram/v1) that the gateway and backend call over the trusted
// internal network. See platform/telegram/README.md.
package main

import (
	"context"
	"errors"
	"log"
	"net"
	"os/signal"
	"syscall"
	"time"

	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
	"go.uber.org/zap"
	"google.golang.org/grpc"

	telegramv1 "scrabble/pkg/proto/telegram/v1"
	pkgtel "scrabble/pkg/telemetry"
	"scrabble/platform/telegram/internal/bot"
	"scrabble/platform/telegram/internal/config"
	"scrabble/platform/telegram/internal/connector"
	"scrabble/platform/telegram/internal/initdata"
	"scrabble/platform/telegram/internal/loginwidget"
)

// telemetryShutdownTimeout bounds the OpenTelemetry flush during process exit.
const telemetryShutdownTimeout = 5 * time.Second

func main() {
	cfg, err := config.Load()
	if err != nil {
		log.Fatalf("telegram: load config: %v", err)
	}
	logger, err := newLogger(cfg.LogLevel)
	if err != nil {
		log.Fatalf("telegram: build logger: %v", err)
	}
	defer func() { _ = logger.Sync() }()

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	if err := run(ctx, cfg, logger); err != nil {
		logger.Fatal("telegram: terminated", zap.Error(err))
	}
}

// run wires the bot and the gRPC server and serves both until the context is
// cancelled.
func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
	tel, err := pkgtel.New(ctx, cfg.Telemetry)
	if err != nil {
		return err
	}
	defer func() {
		shutdownCtx, cancel := context.WithTimeout(context.Background(), telemetryShutdownTimeout)
		defer cancel()
		if err := tel.Shutdown(shutdownCtx); err != nil {
			logger.Warn("telemetry shutdown", zap.Error(err))
		}
	}()
	if err := tel.StartRuntimeMetrics(); err != nil {
		logger.Warn("telemetry: start runtime metrics", zap.Error(err))
	}

	// One bot per configured service language; ValidateInitData tries each token and
	// the push/admin methods route by language.
	var bots []*bot.Bot
	var runtimes []connector.BotRuntime
	var langs []string
	for _, lang := range config.Languages {
		bc, ok := cfg.Bots[lang]
		if !ok {
			continue
		}
		b, err := bot.New(bot.Config{
			Token:      bc.Token,
			APIBaseURL: cfg.APIBaseURL,
			TestEnv:    cfg.TestEnv,
			MiniAppURL: cfg.MiniAppURL,
		}, logger)
		if err != nil {
			return err
		}
		bots = append(bots, b)
		runtimes = append(runtimes, connector.BotRuntime{
			Language:        lang,
			Sender:          b,
			ChannelID:       bc.GameChannelID,
			InitValidator:   initdata.NewHMACValidator(bc.Token),
			WidgetValidator: loginwidget.NewHMACValidator(bc.Token),
		})
		langs = append(langs, lang)
	}
	srv := connector.NewServer(runtimes, logger)

	grpcServer := grpc.NewServer(grpc.StatsHandler(otelgrpc.NewServerHandler()))
	telegramv1.RegisterTelegramServer(grpcServer, srv)

	lis, err := net.Listen("tcp", cfg.GRPCAddr)
	if err != nil {
		return err
	}

	// The long-poll loops and the gRPC server run together; cancelling the context
	// stops every bot loop and gracefully drains the gRPC server.
	for _, b := range bots {
		go b.Run(ctx)
	}
	go func() {
		<-ctx.Done()
		grpcServer.GracefulStop()
	}()

	logger.Info("telegram connector starting",
		zap.String("grpc_addr", cfg.GRPCAddr),
		zap.String("miniapp_url", cfg.MiniAppURL),
		zap.Strings("languages", langs),
		zap.Bool("test_env", cfg.TestEnv))
	if err := grpcServer.Serve(lis); err != nil && !errors.Is(err, grpc.ErrServerStopped) {
		return err
	}
	return nil
}

// newLogger builds a production JSON logger at the given level.
func newLogger(level string) (*zap.Logger, error) {
	var lvl zap.AtomicLevel
	if err := lvl.UnmarshalText([]byte(level)); err != nil {
		return nil, err
	}
	cfg := zap.NewProductionConfig()
	cfg.Level = lvl
	return cfg.Build()
}