plug-sdk/pkg/plug/server.go

package plug

import (
	"context"
	"fmt"
	"net"

	"git.anthrove.art/Anthrove/otter-space-sdk/v3/pkg/database"
	"git.anthrove.art/Anthrove/otter-space-sdk/v3/pkg/models"
	pb "git.anthrove.art/Anthrove/plug-sdk/v3/pkg/grpc"
	"git.anthrove.art/Anthrove/plug-sdk/v3/pkg/telemetry"
	log "github.com/sirupsen/logrus"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/codes"
	"google.golang.org/grpc"
	"google.golang.org/protobuf/types/known/timestamppb"
)

var tracer = otel.Tracer("git.anthrove.art/Anthrove/plug-sdk/v3/pkg/plug")

type Message struct {
	Title     string
	Body      string
	CreatedAt *timestamppb.Timestamp
}

type TaskExecution func(ctx context.Context, userSource models.UserSource, deepScrape bool, apiKey string, cancelFunction func()) error
type SendMessageExecution func(ctx context.Context, userSource models.UserSource, message string) error
type GetMessageExecution func(ctx context.Context, userSource models.UserSource) ([]Message, error)

type Plug struct {
	address               string
	port                  string
	ctx                   context.Context
	taskExecutionFunction TaskExecution
	sendMessageExecution  SendMessageExecution
	getMessageExecution   GetMessageExecution
	source                models.Source
	plugName              string
}

func NewPlug(ctx context.Context, plugName string, address string, port string, source models.Source) Plug {
	return Plug{
		ctx:      ctx,
		address:  address,
		port:     port,
		source:   source,
		plugName: plugName,
	}
}

func (p *Plug) Listen() error {
	ctx, span := tracer.Start(p.ctx, "Listen")
	defer span.End()

	var err error
	var source models.Source

	span.SetAttributes(
		attribute.String("source_display_name", string(p.source.DisplayName)),
		attribute.String("source_domain", string(p.source.Domain)),
	)

	sourceFields := log.Fields{
		"source_display_name": p.source.DisplayName,
		"source_domain":       p.source.Domain,
	}

	serverFields := log.Fields{
		"address": p.address,
		"port":    p.port,
	}

	source, err = database.GetSourceByDomain(ctx, p.source.Domain)
	if err != nil {
		if err.Error() == "Database error: NoDataFound" {
			span.AddEvent("No Source found, initializing source")

			log.WithContext(ctx).WithFields(sourceFields).Info("No Source found, initializing source!")

			source, err = database.CreateSource(ctx, p.source)
			if err != nil {
				span.RecordError(err)
				span.SetStatus(codes.Error, err.Error())
				log.WithError(err).WithFields(sourceFields).Error("Failed to create source")
				panic(err)
			}

			span.AddEvent("Source created")
			log.WithContext(ctx).WithError(err).WithFields(sourceFields).WithField("source_id", source.ID).Info("Source created!")

		} else {
			span.RecordError(err)
			span.SetStatus(codes.Error, err.Error())
			log.WithContext(ctx).WithError(err).WithFields(sourceFields).Error("Failed to get source by domain")
			panic(err)
		}
	}

	p.source = source

	span.SetAttributes(
		attribute.String("source_id", string(p.source.ID)),
	)

	lis, err := net.Listen("tcp", fmt.Sprintf("%s:%s", p.address, p.port))
	if err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, err.Error())
		log.WithContext(ctx).WithError(err).WithFields(serverFields).Error("Failed to listen on address")
		return err
	}

	grpcServer := grpc.NewServer()

	pb.RegisterPlugConnectorServer(grpcServer, NewGrpcServer(p.source, p.taskExecutionFunction, p.sendMessageExecution, p.getMessageExecution))

	err = grpcServer.Serve(lis)
	if err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, err.Error())
		log.WithContext(ctx).WithError(err).Error("Failed to serve gRPC server")
		return err
	}

	return nil
}

func (p *Plug) GetSource() models.Source {
	_, span := tracer.Start(p.ctx, "GetSource")
	defer span.End()

	span.SetAttributes(attribute.String("source_domain", string(p.source.Domain)))
	return p.source
}

func (p *Plug) TaskExecutionFunction(function TaskExecution) {
	_, span := tracer.Start(p.ctx, "TaskExecutionFunction")
	defer span.End()

	p.taskExecutionFunction = function
	span.AddEvent("Task execution function set")
}

func (p *Plug) SendMessageExecution(function SendMessageExecution) {
	_, span := tracer.Start(p.ctx, "SendMessageExecution")
	defer span.End()

	p.sendMessageExecution = function
	span.AddEvent("Send message execution function set")
}

func (p *Plug) GetMessageExecution(function GetMessageExecution) {
	_, span := tracer.Start(p.ctx, "GetMessageExecution")
	defer span.End()

	p.getMessageExecution = function
	span.AddEvent("Get message execution function set")
}

func (p Plug) SetupOpenTelemtry() error {
	ctx, span := tracer.Start(p.ctx, "SetupOpenTelemtry")
	defer span.End()

	err := telemetry.SetupMeterProvider(p.plugName)
	if err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, err.Error())
		log.WithContext(ctx).WithError(err).Error("Failed to setup meter provider")
		return err
	}

	err = telemetry.SetupTraceProvider(ctx, p.plugName)
	if err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, err.Error())
		log.WithContext(ctx).WithError(err).Error("Failed to setup trace provider")
		return err
	}

	return nil
}