Merge pull request #15 from PDOK/PDOK-17771-slack-integration

Pdok 17771 slack integration

Author: Daimanta

pkg/integrations/logging/logging.go

@@ -0,0 +1,51 @@
+package logging
+
+import (
+	"github.com/pdok/smooth-operator/pkg/integrations/slack"
+	zap "go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+type StdoutWriter struct {
+}
+
+func (s StdoutWriter) Write(p []byte) (n int, err error) {
+	println(string(p))
+	return len(p), nil
+}
+
+func SetupLogger(operatorName string, slackWebhookUrl string, minLogLevel zapcore.LevelEnabler) (*zap.Logger, error) {
+	// Standard output writer
+	stdoutSyncer := zapcore.Lock(zapcore.AddSync(StdoutWriter{}))
+
+	// Slack writer for errors
+	slackSyncer := zapcore.Lock(zapcore.AddSync(&slack.SlackZapWriter{
+		OperatorName:    operatorName,
+		SlackWebhookUrl: slackWebhookUrl,
+	}))
+
+	// Encoder configuration for human-readable output
+	encoderConfig := zap.NewProductionEncoderConfig()
+	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+
+	// Create a core for stdout (all levels)
+	stdoutCore := zapcore.NewCore(
+		zapcore.NewConsoleEncoder(encoderConfig),
+		stdoutSyncer,
+		minLogLevel,
+	)
+
+	// Create a core for Slack (errors only)
+	slackCore := zapcore.NewCore(
+		zapcore.NewConsoleEncoder(encoderConfig),
+		slackSyncer,
+		zapcore.ErrorLevel,
+	)
+
+	// Combine cores
+	combinedCore := zapcore.NewTee(stdoutCore, slackCore)
+
+	// Build the logger
+	logger := zap.New(combinedCore, zap.AddCaller())
+	return logger, nil
+}

pkg/integrations/logging/logging_test.go

@@ -0,0 +1,18 @@
+package logging
+
+import (
+	"go.uber.org/zap/zapcore"
+	"testing"
+)
+
+func TestLogger(t *testing.T) {
+	logger, err := SetupLogger("myOperator", "", zapcore.InfoLevel)
+	if err != nil {
+		panic(err)
+	}
+
+	// This should log a message to stdout
+	// If slackWebhookUrl is provided, it will use the URL to send a Slack message
+	logger.Info("Foo")
+	logger.Error("Bar")
+}

pkg/integrations/slack/slack.go

@@ -0,0 +1,124 @@
+package slack
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+type SlackRequest struct {
+	Attachments []SlackElement `json:"attachments"`
+	Text        *string        `json:"text,omitempty"`
+}
+
+type SlackElement struct {
+	Color  string       `json:"color"`
+	Blocks []SlackBlock `json:"blocks"`
+}
+
+type SlackBlock struct {
+	Type   string            `json:"type"`
+	Text   SlackValueBlock   `json:"text"`
+	Fields []SlackValueBlock `json:"fields"`
+}
+
+type SlackValueBlock struct {
+	Type string `json:"type"`
+	Text string `json:"text"`
+}
+
+func GetSlackBlock(generalMessage string, jobUrl string, color string, datasetName string) SlackRequest {
+	var slackBlock = SlackBlock{
+		Type: "section",
+		Text: SlackValueBlock{
+			Type: "mrkdwn",
+			Text: generalMessage,
+		},
+		Fields: []SlackValueBlock{{
+			Type: "mrkdwn",
+			Text: "*Dataset*",
+		}, {
+			Type: "mrkdwn",
+			Text: "*Job*",
+		}, {
+			Type: "mrkdwn",
+			Text: datasetName,
+		}, {
+			Type: "mrkdwn",
+			Text: jobUrl,
+		}},
+	}
+
+	slackElement := SlackElement{
+		Color:  color,
+		Blocks: []SlackBlock{slackBlock},
+	}
+
+	return SlackRequest{
+		Attachments: []SlackElement{slackElement},
+	}
+}
+
+func GetSlackErrorMessage(message string, bundle string, color string) SlackRequest {
+	var slackBlock = SlackBlock{
+		Type: "section",
+		Text: SlackValueBlock{
+			Type: "mrkdwn",
+			Text: message,
+		},
+		Fields: []SlackValueBlock{{
+			Type: "mrkdwn",
+			Text: "*Bundle*",
+		}, {
+			Type: "mrkdwn",
+			Text: bundle,
+		}},
+	}
+
+	slackElement := SlackElement{
+		Color:  color,
+		Blocks: []SlackBlock{slackBlock},
+	}
+
+	return SlackRequest{
+		Attachments: []SlackElement{slackElement},
+	}
+}
+
+func GetSimpleSlackErrorMessage(message string) SlackRequest {
+	return SlackRequest{
+		Attachments: nil,
+		Text:        &message,
+	}
+}
+
+func SendSlackRequest(slackRequest SlackRequest, slackUrl string) error {
+	marshalled, err := json.Marshal(slackRequest)
+	if err != nil {
+		return err
+	}
+	response, err := http.DefaultClient.Post(slackUrl, "application/json", strings.NewReader(string(marshalled)))
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	return nil
+}
+
+type SlackZapWriter struct {
+	OperatorName    string
+	SlackWebhookUrl string
+}
+
+func (slackWriter *SlackZapWriter) Sync() error {
+	return nil
+}
+
+func (slackWriter *SlackZapWriter) Write(p []byte) (n int, err error) {
+	if slackWriter.SlackWebhookUrl != "" {
+		slackRequest := GetSimpleSlackErrorMessage(fmt.Sprintf("%s: %s", slackWriter.OperatorName, string(p)))
+		SendSlackRequest(slackRequest, slackWriter.SlackWebhookUrl)
+	}
+	return len(p), nil
+}