func NewSlowLogWorker(logger *pct.Logger, name string) *SlowLogWorker {
w := &SlowLogWorker{
logger: logger,
name: name,
status: pct.NewStatus([]string{name}),
}
return w
}
func NewMockServiceManager(name string, readyChan chan bool, traceChan chan string) *MockServiceManager {
m := &MockServiceManager{
name: name,
readyChan: readyChan,
traceChan: traceChan,
status: pct.NewStatus([]string{name}),
}
return m
}
func NewManager(logger *pct.Logger, monitor Monitor) *Manager {
m := &Manager{
logger: logger,
monitor: monitor,
// --
status: pct.NewStatus([]string{SERVICE_NAME}),
}
return m
}
func NewSender(logger *pct.Logger, client pct.WebsocketClient) *Sender {
s := &Sender{
logger: logger,
client: client,
sync: pct.NewSyncChan(),
status: pct.NewStatus([]string{"data-sender"}),
}
return s
}
func NewManager(logger *pct.Logger) *Manager {
m := &Manager{
logger: logger,
// --
service: make(map[string]Service),
status: pct.NewStatus([]string{SERVICE_NAME}),
}
return m
}
func NewManager(client pct.WebsocketClient, logChan chan *proto.LogEntry) *Manager {
m := &Manager{
client: client,
logChan: logChan,
// --
status: pct.NewStatus([]string{"log"}),
mux: &sync.RWMutex{},
}
return m
}
func NewManager(logger *pct.Logger, instanceRepo *instance.Repo, connFactory mysql.ConnectionFactory) *Manager {
m := &Manager{
logger: logger,
instanceRepo: instanceRepo,
connFactory: connFactory,
// --
status: pct.NewStatus([]string{SERVICE_NAME}),
}
return m
}
func NewManager(logger *pct.Logger, configDir string, api pct.APIConnector) *Manager {
repo := NewRepo(pct.NewLogger(logger.LogChan(), "instance-repo"), configDir, api)
m := &Manager{
logger: logger,
configDir: configDir,
// --
status: pct.NewStatus([]string{"instance", "instance-repo"}),
repo: repo,
}
return m
}
func NewSender(logger *pct.Logger, client pct.WebsocketClient) *Sender {
s := &Sender{
logger: logger,
client: client,
sync: pct.NewSyncChan(),
status: pct.NewStatus([]string{"data-sender", "data-sender-last", "data-sender-1d"}),
lastStats: NewSenderStats(0),
dailyStats: NewSenderStats(24 * time.Hour),
}
return s
}
func NewManager(logger *pct.Logger, dataDir string, hostname string, client pct.WebsocketClient) *Manager {
m := &Manager{
logger: logger,
dataDir: dataDir,
hostname: hostname,
client: client,
// --
status: pct.NewStatus([]string{"data"}),
mux: &sync.Mutex{},
}
return m
}
func NewMonitor(name string, config *Config, logger *pct.Logger, conn mysql.Connector) *Monitor {
m := &Monitor{
name: name,
config: config,
logger: logger,
conn: conn,
// --
sync: pct.NewSyncChan(),
status: pct.NewStatus([]string{name, name + "-mysql"}),
}
return m
}
func NewDiskvSpooler(logger *pct.Logger, dataDir string, hostname string) *DiskvSpooler {
s := &DiskvSpooler{
logger: logger,
dataDir: dataDir,
hostname: hostname,
// --
dataChan: make(chan *proto.Data, WRITE_BUFFER),
sync: pct.NewSyncChan(),
status: pct.NewStatus([]string{"data-spooler"}),
mux: new(sync.Mutex),
}
return s
}
func NewMonitor(name string, config *Config, logger *pct.Logger) *Monitor {
m := &Monitor{
name: name,
config: config,
logger: logger,
// --
prevCPUval: make(map[string][]float64),
prevCPUsum: make(map[string]float64),
status: pct.NewStatus([]string{name}),
sync: pct.NewSyncChan(),
}
return m
}
func NewMonitor(logger *pct.Logger, mysqlConnFactory mysql.ConnectionFactory) mrms.Monitor {
m := &Monitor{
logger: logger,
mysqlConnFactory: mysqlConnFactory,
// --
mysqlInstances: make(map[string]*MysqlInstance),
// --
status: pct.NewStatus([]string{MONITOR_NAME}),
sync: pct.NewSyncChan(),
globalChan: make(chan string, 100),
}
return m
}
func NewManager(logger *pct.Logger, factory MonitorFactory, clock ticker.Manager, spool data.Spooler, im *instance.Repo) *Manager {
m := &Manager{
logger: logger,
factory: factory,
clock: clock,
spool: spool,
im: im,
// --
reportChan: make(chan *Report, 3),
monitors: make(map[string]Monitor),
status: pct.NewStatus([]string{"sysconfig", "sysconfig-spooler"}),
mux: &sync.RWMutex{},
}
return m
}
func NewManager(logger *pct.Logger, configDir string, api pct.APIConnector, mrm mrms.Monitor) *Manager {
repo := NewRepo(pct.NewLogger(logger.LogChan(), "instance-repo"), configDir, api)
m := &Manager{
logger: logger,
configDir: configDir,
api: api,
// --
status: pct.NewStatus([]string{"instance", "instance-repo", "instance-mrms"}),
repo: repo,
mrm: mrm,
mrmChans: make(map[string]<-chan bool),
mrmsGlobalChan: make(chan string, 100), // monitor up to 100 instances
}
return m
}
func NewManager(logger *pct.Logger, factory MonitorFactory, clock ticker.Manager, spool data.Spooler, im *instance.Repo) *Manager {
m := &Manager{
logger: logger,
factory: factory,
clock: clock,
spool: spool,
im: im,
// --
monitors: make(map[string]Monitor),
status: pct.NewStatus([]string{"mm"}),
aggregators: make(map[uint]*Binding),
mux: &sync.RWMutex{},
}
return m
}
func NewMonitor(name string, config *Config, logger *pct.Logger, conn mysql.Connector, mrm mrms.Monitor) *Monitor {
m := &Monitor{
name: name,
config: config,
logger: logger,
conn: conn,
// --
connectedChan: make(chan bool, 1),
restartChan: nil,
status: pct.NewStatus([]string{name, name + "-mysql"}),
sync: pct.NewSyncChan(),
collectLimit: float64(config.Collect) * 0.1, // 10% of Collect time
mrm: mrm,
}
return m
}
func NewDiskvSpooler(logger *pct.Logger, dataDir, trashDir, hostname string, limits proto.DataSpoolLimits) *DiskvSpooler {
s := &DiskvSpooler{
logger: logger,
dataDir: dataDir,
trashDir: trashDir,
hostname: hostname,
limits: limits,
// --
dataChan: make(chan *proto.Data, DEFAULT_DATA_MAX_FILES),
sync: pct.NewSyncChan(),
status: pct.NewStatus([]string{"data-spooler", "data-spooler-count", "data-spooler-size", "data-spooler-oldest"}),
mux: new(sync.Mutex),
fileSize: make(map[string]int),
}
return s
}
func NewAgent(config *Config, logger *pct.Logger, api pct.APIConnector, client pct.WebsocketClient, services map[string]pct.ServiceManager) *Agent {
agent := &Agent{
config: config,
api: api,
configMux: &sync.RWMutex{},
logger: logger,
client: client,
services: services,
updater: pct.NewUpdater(logger, api, pct.PublicKey, os.Args[0], VERSION),
// --
status: pct.NewStatus([]string{"agent", "agent-cmd-handler"}),
cmdChan: make(chan *proto.Cmd, CMD_QUEUE_SIZE),
statusChan: make(chan *proto.Cmd, STATUS_QUEUE_SIZE),
}
return agent
}
func NewManager(logger *pct.Logger, mysqlFactory mysql.ConnectionFactory, clock ticker.Manager, iterFactory IntervalIterFactory, workerFactory WorkerFactory, spool data.Spooler, im *instance.Repo) *Manager {
m := &Manager{
logger: logger,
mysqlFactory: mysqlFactory,
clock: clock,
iterFactory: iterFactory,
workerFactory: workerFactory,
spool: spool,
im: im,
// --
mux: new(sync.RWMutex),
tickChan: make(chan time.Time),
workers: make(map[Worker]*Interval),
workersMux: new(sync.RWMutex),
workerDoneChan: make(chan Worker, 2),
status: pct.NewStatus([]string{"qan", "qan-log-parser", "qan-last-interval", "qan-next-interval"}),
sync: pct.NewSyncChan(),
oldSlowLogs: make(map[string]int),
}
return m
}
func NewWebsocketClient(logger *pct.Logger, api pct.APIConnector, link string) (*WebsocketClient, error) {
name := logger.Service()
c := &WebsocketClient{
logger: logger,
api: api,
link: link,
// --
conn: nil,
recvChan: make(chan *proto.Cmd, RECV_BUFFER_SIZE),
sendChan: make(chan *proto.Reply, SEND_BUFFER_SIZE),
connectChan: make(chan bool, 1),
errChan: make(chan error, 2),
backoff: pct.NewBackoff(5 * time.Minute),
sendSync: pct.NewSyncChan(),
recvSync: pct.NewSyncChan(),
mux: new(sync.Mutex),
name: name,
status: pct.NewStatus([]string{name, name + "-link"}),
}
return c, nil
}
func NewRealAnalyzer(logger *pct.Logger, config Config, iter IntervalIter, mysqlConn mysql.Connector, restartChan <-chan bool, worker Worker, clock ticker.Manager, spool data.Spooler) *RealAnalyzer {
name := logger.Service()
a := &RealAnalyzer{
logger: logger,
config: config,
iter: iter,
mysqlConn: mysqlConn,
restartChan: restartChan,
worker: worker,
clock: clock,
spool: spool,
// --
name: name,
mysqlConfiguredChan: make(chan bool, 1),
workerDoneChan: make(chan *Interval, 1),
status: pct.NewStatus([]string{name, name + "-last-interval", name + "-next-interval"}),
runSync: pct.NewSyncChan(),
configureMySQLSync: pct.NewSyncChan(),
mux: &sync.RWMutex{},
}
return a
}
func NewManager(
logger *pct.Logger,
clock ticker.Manager,
im *instance.Repo,
mrm mrms.Monitor,
mysqlFactory mysql.ConnectionFactory,
analyzerFactory AnalyzerFactory,
) *Manager {
m := &Manager{
logger: logger,
clock: clock,
im: im,
mrm: mrm,
mysqlFactory: mysqlFactory,
analyzerFactory: analyzerFactory,
// --
mux: &sync.RWMutex{},
analyzers: make(map[uint]AnalyzerInstance),
status: pct.NewStatus([]string{"qan"}),
}
return m
}
func NewRelay(client pct.WebsocketClient, logChan chan *proto.LogEntry, logFile string, logLevel byte, offline bool) *Relay {
r := &Relay{
client: client,
logChan: logChan,
logFile: logFile,
logLevel: logLevel,
offline: offline,
// --
logLevelChan: make(chan byte),
logFileChan: make(chan string),
firstBuf: make([]*proto.LogEntry, BUFFER_SIZE),
secondBuf: make([]*proto.LogEntry, BUFFER_SIZE),
status: pct.NewStatus([]string{
"log-relay",
"log-file",
"log-level",
"log-chan",
"log-buf1",
"log-buf2",
}),
}
return r
}