flamingo

package
v3.8.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 7, 2024 License: MIT Imports: 19 Imported by: 140

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AppVersion added in v3.2.1 

func AppVersion() string

AppVersion returns the application version set this during build with `go build -ldflags "-X flamingo.me/flamingo/v3/framework/flamingo.appVersion=1.2.3"`.

func BindEventSubscriber 

func BindEventSubscriber(injector *dingo.Injector) *dingo.Binding

BindEventSubscriber is a helper to bind a private event Subscriber via Dingo

func BindTemplateFunc 

func BindTemplateFunc(injector *dingo.Injector, name string, fnc TemplateFunc)

BindTemplateFunc makes sure a template function is correctly bound via dingo

func LogFunc added in v3.7.0 

func LogFunc(l Logger, fields map[LogKey]any) func(f func(l Logger, args ...any), args ...any)
Example 
package main

import (
	"fmt"
	"io"
	"log"
	"strings"

	"flamingo.me/flamingo/v3/framework/flamingo"
)

func createLogger(recorder io.Writer) flamingo.Logger {
	var l = new(flamingo.StdLogger)
	l.Logger = *log.New(recorder, "TEST--", 0)

	return l
}

func main() {
	recorder := &strings.Builder{}

	// the flamingo.Logger is normally obtained via injection
	logger := createLogger(recorder)

	// we can create a log function which we use later to log messages with the fields we define here
	logFunc := flamingo.LogFunc(logger, map[flamingo.LogKey]any{
		flamingo.LogKeyBusinessID: "example",
		flamingo.LogKeyCategory:   "test",
	})

	// the wanted log level is defined by passing the corresponding method from the flamingo.Logger interface
	logFunc(flamingo.Logger.Info, "my", "log", "args")
	logFunc(flamingo.Logger.Warn, "my", "log", "args")
	logFunc(flamingo.Logger.Debug, "my", "log", "args")
	// if we do not give the level, it will be Info
	logFunc(nil, "my", "log", "args")

	fmt.Println(recorder.String())

}

Output:

TEST--WithFields map[businessId:example category:test]
TEST--info: mylogargs
TEST--WithFields map[businessId:example category:test]
TEST--warn: mylogargs
TEST--WithFields map[businessId:example category:test]
TEST--debug: mylogargs
TEST--WithFields map[businessId:example category:test]
TEST--info: mylogargs

func LogFuncWithContext added in v3.7.0 

func LogFuncWithContext(l Logger, fields map[LogKey]any) func(ctx context.Context, f func(l Logger, args ...any), args ...any)
Example 
package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"strings"

	"flamingo.me/flamingo/v3/framework/flamingo"
)

func createLogger(recorder io.Writer) flamingo.Logger {
	var l = new(flamingo.StdLogger)
	l.Logger = *log.New(recorder, "TEST--", 0)

	return l
}

func main() {
	recorder := &strings.Builder{}

	// the flamingo.Logger is normally obtained via injection
	logger := createLogger(recorder)

	// we can create a log function which we use later to log messages with the fields we define here
	// the log function will expect a context on each call
	logFunc := flamingo.LogFuncWithContext(logger, map[flamingo.LogKey]any{
		flamingo.LogKeyBusinessID: "example",
	})

	ctx := context.Background()

	// the current context is the first argument. It is up to the logger implementation what to do with it
	// the standard flamingo zap.Logger can add the session hash aon tracing information as fields
	// the StdLogger we use here, does nothing with the context
	// the wanted log level is defined by passing the corresponding method from the flamingo.Logger interface
	logFunc(ctx, flamingo.Logger.Info, "my", "log", "args")
	logFunc(ctx, flamingo.Logger.Warn, "my", "log", "args")
	logFunc(ctx, flamingo.Logger.Debug, "my", "log", "args")
	// if we do not give the level, it will be Info
	logFunc(ctx, nil, "my", "log", "args")

	fmt.Println(recorder.String())

}

Output:

TEST--WithFields map[businessId:example]
TEST--info: mylogargs
TEST--WithFields map[businessId:example]
TEST--warn: mylogargs
TEST--WithFields map[businessId:example]
TEST--debug: mylogargs
TEST--WithFields map[businessId:example]
TEST--info: mylogargs

Types

type DefaultEventRouter 

type DefaultEventRouter struct {
	// contains filtered or unexported fields
}

DefaultEventRouter is a default event routing implementation

func (*DefaultEventRouter) Dispatch 

func (d *DefaultEventRouter) Dispatch(ctx context.Context, event Event)

Dispatch calls the event's Dispatch method on each subscriber

func (*DefaultEventRouter) Inject 

func (d *DefaultEventRouter) Inject(provider eventSubscriberProvider, logger Logger)

Inject eventSubscriberProvider dependency

type Event 

type Event interface{}

Event defines some event

type EventRouter 

type EventRouter interface {
	Dispatch(ctx context.Context, event Event)
}

EventRouter routes events

type LogKey 

type LogKey string

LogKey is a logging key constant 

const (
	LogKeyAccesslog         LogKey = "accesslog" // LogKeyAccesslog marks a logmessage belonging to an (incoming) call (value should be 1)
	LogKeyApicall           LogKey = "apicall"   // LogKeyApicall marks a logmessage belonging to an (outgoing) api call (value should be 1)
	LogKeyArea              LogKey = "area"
	LogKeyBusinessID        LogKey = "businessId"
	LogKeyCategory          LogKey = "category"
	LogKeyModule            LogKey = "module"
	LogKeySubCategory       LogKey = "sub_category"
	LogKeyClientIP          LogKey = "client_ip"
	LogKeyCode              LogKey = "code"
	LogKeyConnectionStatus  LogKey = "connection_status"
	LogKeyCorrelationID     LogKey = "correlationId"
	LogKeyTraceID           LogKey = "traceID"
	LogKeySpanID            LogKey = "spanID"
	LogKeyLevel             LogKey = "level"
	LogKeyMessage           LogKey = "message"
	LogKeyMethod            LogKey = "method"
	LogKeySession           LogKey = "session"
	LogKeyPath              LogKey = "path"
	LogKeyReferer           LogKey = "referer"
	LogKeyRequest           LogKey = "request"
	LogKeyRequestTime       LogKey = "request_time"
	LogKeyRequestedEndpoint LogKey = "requested_endpoint"
	LogKeyRequestedURL      LogKey = "requested_url"
	LogKeyResponse          LogKey = "response"
	LogKeyResponseCode      LogKey = "response_code"
	LogKeyResponseTime      LogKey = "response_time"
	LogKeySource            LogKey = "source"
	LogKeyTimestamp         LogKey = "@timestamp"
	LogKeyTrace             LogKey = "trace"
)

Common logger field keys

type Logger 

type Logger interface {
	WithContext(ctx context.Context) Logger

	Debug(args ...interface{})
	Info(args ...interface{})
	Warn(args ...interface{})
	Error(args ...interface{})
	Fatal(args ...interface{})
	Panic(args ...interface{})

	Debugf(log string, args ...interface{})

	WithField(key LogKey, value interface{}) Logger
	WithFields(fields map[LogKey]interface{}) Logger

	Flush()
}

Logger defines a standard Flamingo logger interfaces

Example

In this example we see the normal usecase of a logger 

package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"strings"

	"flamingo.me/flamingo/v3/framework/flamingo"
)

func createLogger(recorder io.Writer) flamingo.Logger {
	var l = new(flamingo.StdLogger)
	l.Logger = *log.New(recorder, "TEST--", 0)

	return l
}

func main() {
	recorder := &strings.Builder{}

	// the flamingo.Logger is normally obtained via injection
	logger := createLogger(recorder)

	// create a new child logger witch additional fields
	logger = logger.WithFields(map[flamingo.LogKey]any{
		flamingo.LogKeyBusinessID: "example",
		flamingo.LogKeyCategory:   "test",
	})

	// we can also add single fields
	logger = logger.WithField(flamingo.LogKeySubCategory, "another field")

	// we can add the current context. It is up to the logger implementation what to do with it
	// the standard flamingo zap.Logger can add the session hash aon tracing information as fields
	// the StdLogger we use here, does nothing with the context
	logger = logger.WithContext(context.Background())

	// log some messages in different levels
	logger.Info("my", "log", "args")
	logger.Warn("my", "log", "args")
	logger.Debug("my", "log", "args")

	fmt.Println(recorder.String())

}

Output:

TEST--WithFields map[businessId:example category:test]
TEST--WithField sub_category another field
TEST--info: mylogargs
TEST--warn: mylogargs
TEST--debug: mylogargs

type NullLogger 

type NullLogger struct{}

NullLogger does not log

func (NullLogger) Debug 

func (NullLogger) Debug(_ ...interface{})

Debug null-implementation

func (NullLogger) Debugf 

func (NullLogger) Debugf(_ string, _ ...interface{})

Debugf null-implementation

func (NullLogger) Error 

func (NullLogger) Error(_ ...interface{})

Error null-implementation

func (NullLogger) Fatal 

func (NullLogger) Fatal(_ ...interface{})

Fatal null-implementation

func (NullLogger) Flush 

func (n NullLogger) Flush()

Flush null-implementation

func (NullLogger) Info 

func (NullLogger) Info(_ ...interface{})

Info null-implementation

func (NullLogger) Panic 

func (NullLogger) Panic(_ ...interface{})

Panic null-implementation

func (NullLogger) Warn 

func (NullLogger) Warn(_ ...interface{})

Warn null-implementation

func (NullLogger) WithContext 

func (n NullLogger) WithContext(_ context.Context) Logger

WithContext null-implementation

func (NullLogger) WithField 

func (n NullLogger) WithField(_ LogKey, _ interface{}) Logger

WithField null-implementation

func (NullLogger) WithFields 

func (n NullLogger) WithFields(_ map[LogKey]interface{}) Logger

WithFields null-implementation

type PartialTemplateEngine 

type PartialTemplateEngine interface {
	RenderPartials(ctx context.Context, templateName string, data interface{}, partials []string) (map[string]io.Reader, error)
}

PartialTemplateEngine is used for progressive enhancements / rendering of partial template areas usually this is requested via the appropriate javascript headers and taken care of in the framework renderer

type ServerShutdownEvent 

type ServerShutdownEvent struct{}

ServerShutdownEvent is dispatched when a server is stopped (not for CLI commands)

type ServerStartEvent 

type ServerStartEvent struct {
	Port string
}

ServerStartEvent is dispatched when a server is started (not for CLI commands)

type SessionModule 

type SessionModule struct {
	// contains filtered or unexported fields
}

SessionModule for session management

func (*SessionModule) Configure 

func (m *SessionModule) Configure(injector *dingo.Injector)

Configure DI

func (*SessionModule) CueConfig added in v3.1.0 

func (*SessionModule) CueConfig() string

CueConfig defines the session config scheme

func (*SessionModule) FlamingoLegacyConfigAlias added in v3.1.0 

func (m *SessionModule) FlamingoLegacyConfigAlias() map[string]string

FlamingoLegacyConfigAlias maps legacy config to new

func (*SessionModule) Inject 

func (m *SessionModule) Inject(config *struct {
	// session config is optional to allow usage of the DefaultConfig
	Backend  string `inject:"config:flamingo.session.backend"`
	Secret   string `inject:"config:flamingo.session.secret"`
	FileName string `inject:"config:flamingo.session.file"`
	Secure   bool   `inject:"config:flamingo.session.cookie.secure"`
	SameSite string `inject:"config:flamingo.session.cookie.sameSite"`
	// float64 is used due to the injection as config from json - int is not possible on this
	StoreLength          float64 `inject:"config:flamingo.session.store.length"`
	MaxAge               float64 `inject:"config:flamingo.session.max.age"`
	Path                 string  `inject:"config:flamingo.session.cookie.path"`
	RedisURL             string  `inject:"config:flamingo.session.redis.url"`
	RedisHost            string  `inject:"config:flamingo.session.redis.host"`
	RedisPassword        string  `inject:"config:flamingo.session.redis.password"`
	RedisIdleConnections float64 `inject:"config:flamingo.session.redis.idle.connections"`
	RedisDatabase        int     `inject:"config:flamingo.session.redis.database,optional"`
	RedisTLS             bool    `inject:"config:flamingo.session.redis.tls,optional"`
	RedisClusterMode     bool    `inject:"config:flamingo.session.redis.clusterMode,optional"`
	RedisTimeout         string  `inject:"config:flamingo.session.redis.timeout,optional"`
	CheckSession         bool    `inject:"config:flamingo.session.healthcheck,optional"`
})

Inject dependencies

type ShutdownEvent 

type ShutdownEvent struct{}

ShutdownEvent is dispatched when the application shuts down

type StartupEvent 

type StartupEvent struct{}

StartupEvent is dispatched when the application starts

type StdLogger 

type StdLogger struct {
	Logger log.Logger
}

StdLogger uses the go stdlib logger for logging

func (*StdLogger) Debug 

func (l *StdLogger) Debug(args ...interface{})

Debug logs output

func (*StdLogger) Debugf 

func (l *StdLogger) Debugf(f string, args ...interface{})

Debugf outputs the formatted debug string

func (*StdLogger) Error 

func (l *StdLogger) Error(args ...interface{})

Error log

func (*StdLogger) Fatal added in v3.4.0 

func (l *StdLogger) Fatal(args ...interface{})

func (*StdLogger) Flush 

func (l *StdLogger) Flush()

Flush does nothing

func (*StdLogger) Info 

func (l *StdLogger) Info(args ...interface{})

Info log output

func (*StdLogger) Panic added in v3.4.0 

func (l *StdLogger) Panic(args ...interface{})

func (*StdLogger) Warn 

func (l *StdLogger) Warn(args ...interface{})

Warn log output

func (*StdLogger) WithContext 

func (l *StdLogger) WithContext(_ context.Context) Logger

WithContext currently does nothing

func (*StdLogger) WithField 

func (l *StdLogger) WithField(key LogKey, value interface{}) Logger

WithField currently logs the field

func (*StdLogger) WithFields 

func (l *StdLogger) WithFields(fields map[LogKey]interface{}) Logger

WithFields currently logs the fields

type TemplateEngine 

type TemplateEngine interface {
	Render(context context.Context, name string, data interface{}) (io.Reader, error)
}

TemplateEngine defines the basic template engine

type TemplateFunc 

type TemplateFunc interface {
	Func(ctx context.Context) interface{}
}

TemplateFunc defines an interface for a custom function to be used in gotemplates/pug templates

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.