121 lines
2.9 KiB
Go
121 lines
2.9 KiB
Go
package logmower
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
)
|
|
|
|
func initializeIndexes(ctx context.Context, col *mongo.Collection) error {
|
|
ind := col.Indexes()
|
|
|
|
// (does not create duplicates)
|
|
_, err := ind.CreateOne(mongoTimeoutCtx(ctx), mongo.IndexModel{
|
|
Keys: bson.D{{Key: mLogKeyFileBasename, Value: 1}, {Key: mLogKeyOffset, Value: -1}},
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
// when editing, also edit everything in this file!
|
|
type (
|
|
mLog struct {
|
|
RecordMetadata
|
|
|
|
Content any
|
|
ContainerTime time.Time
|
|
StdErr bool
|
|
|
|
// added by toBson()
|
|
ShipTime time.Time
|
|
}
|
|
RecordMetadata struct {
|
|
HostInfo HostInfo
|
|
File string
|
|
Offset int64 // byte offset where log entry ends at
|
|
}
|
|
)
|
|
|
|
const (
|
|
// used outside fromBson and toBson
|
|
mLogKeyHostId = mLogKeyHostInfo + "." + mLogKeyId
|
|
)
|
|
|
|
// Don't use direct strings in bson types. Use the constants as keys.
|
|
// This ensures keys (and subkeys) are consistent, at least within the package.
|
|
|
|
const (
|
|
mLogKeyHostInfo = "host_info"
|
|
mLogKeyId = "id"
|
|
mLogKeyName = "name"
|
|
mLogKeyArch = "arch"
|
|
|
|
mLogKeyFileBasename = "file"
|
|
mLogKeyOffset = "offset"
|
|
mLogKeyContent = "content"
|
|
mLogKeyContainerTime = "container_time"
|
|
mLogKeyStderr = "stderr"
|
|
mLogKeyShipTime = "ship_time"
|
|
)
|
|
|
|
// not using marshal, since it is <0.1x performance
|
|
func (l *mLog) toBson() bson.M {
|
|
return bson.M{
|
|
mLogKeyHostInfo: bson.M{
|
|
mLogKeyId: l.HostInfo.Id,
|
|
mLogKeyName: l.HostInfo.Name,
|
|
mLogKeyArch: l.HostInfo.Arch,
|
|
},
|
|
mLogKeyFileBasename: l.File,
|
|
mLogKeyOffset: l.Offset,
|
|
mLogKeyContent: l.Content,
|
|
mLogKeyContainerTime: l.ContainerTime,
|
|
mLogKeyStderr: l.StdErr,
|
|
|
|
mLogKeyShipTime: time.Now(),
|
|
}
|
|
}
|
|
|
|
// really, mongo should support tagged structs
|
|
func mLogfromBson(b *bson.Raw) mLog {
|
|
return mLog{
|
|
RecordMetadata: RecordMetadata{
|
|
HostInfo: HostInfo{
|
|
Id: bsonLookupStringValue(b, mLogKeyHostInfo, mLogKeyId),
|
|
Name: bsonLookupStringValue(b, mLogKeyHostInfo, mLogKeyName),
|
|
Arch: bsonLookupStringValue(b, mLogKeyHostInfo, mLogKeyArch),
|
|
},
|
|
File: bsonLookupStringValue(b, mLogKeyFileBasename),
|
|
Offset: bsonLookupInt64(b, mLogKeyOffset),
|
|
},
|
|
Content: bsonLookupStringValue(b, mLogKeyContent),
|
|
ContainerTime: bsonLookupTime(b, mLogKeyContainerTime),
|
|
StdErr: bsonLookupBoolean(b, mLogKeyStderr),
|
|
ShipTime: bsonLookupTime(b, mLogKeyShipTime),
|
|
}
|
|
}
|
|
|
|
// default values without ok
|
|
|
|
func bsonLookupBoolean(b *bson.Raw, key ...string) bool {
|
|
v, _ := b.Lookup(key...).BooleanOK()
|
|
return v
|
|
}
|
|
|
|
func bsonLookupStringValue(b *bson.Raw, key ...string) string {
|
|
v, _ := b.Lookup(key...).StringValueOK()
|
|
return v
|
|
}
|
|
|
|
func bsonLookupInt64(b *bson.Raw, key ...string) int64 {
|
|
v, _ := b.Lookup(key...).Int64OK()
|
|
return v
|
|
}
|
|
|
|
func bsonLookupTime(b *bson.Raw, key ...string) time.Time {
|
|
v, _ := b.Lookup(key...).TimeOK()
|
|
return v
|
|
}
|