Example #1
0
func BuildCommonSMSContent(event *model.Event) string {
	return fmt.Sprintf(
		"[P%d][%s][%s][][%s %s %s %s %s%s%s][O%d %s]",
		event.Priority(),
		event.Status,
		event.Endpoint,
		event.Note(),
		event.Func(),
		event.Metric(),
		utils.SortedTags(event.PushedTags),
		utils.ReadableFloat(event.LeftValue),
		event.Operator(),
		utils.ReadableFloat(event.RightValue()),
		event.CurrentStep,
		event.FormattedTime(),
	)
}
Example #2
0
func BuildCommonQQContent(event *model.Event) string {
	link := g.Link(event)
	return fmt.Sprintf(
		"%s\r\nP%d\r\nEndpoint:%s\r\nMetric:%s\r\nTags:%s\r\n%s: %s%s%s\r\nNote:%s\r\nMax:%d, Current:%d\r\nTimestamp:%s\r\n%s\r\n",
		event.Status,
		event.Priority(),
		event.Endpoint,
		event.Metric(),
		utils.SortedTags(event.PushedTags),
		event.Func(),
		utils.ReadableFloat(event.LeftValue),
		event.Operator(),
		utils.ReadableFloat(event.RightValue()),
		event.Note(),
		event.MaxStep(),
		event.CurrentStep,
		event.FormattedTime(),
		link,
	)
}
Example #3
0
// 根据item,更新db存储. 不用本地缓存 优化db访问频率.
func updateIndexFromOneItem(item *cmodel.GraphItem, conn *sql.DB) error {
	if item == nil {
		return nil
	}

	endpoint := item.Endpoint
	ts := item.Timestamp
	var endpointId int64 = -1
	sqlDuplicateString := " ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id), ts=VALUES(ts)" //第一个字符是空格

	// endpoint表
	{
		sqlStr := "INSERT INTO endpoint(endpoint, ts, t_create) VALUES (?, ?, now())" + sqlDuplicateString
		ret, err := conn.Exec(sqlStr, endpoint, ts)
		if err != nil {
			log.Println(err)
			return err
		}

		endpointId, err = ret.LastInsertId()
		if err != nil {
			log.Println(err)
			return err
		}
	}

	// tag_endpoint表
	{
		sqlStr := "INSERT INTO tag_endpoint(tag, endpoint_id, ts, t_create) VALUES (?, ?, ?, now())" + sqlDuplicateString
		for tagKey, tagVal := range item.Tags {
			tag := fmt.Sprintf("%s=%s", tagKey, tagVal)

			ret, err := conn.Exec(sqlStr, tag, endpointId, ts)
			if err != nil {
				log.Println(err)
				return err
			}

			_, err = ret.LastInsertId()
			if err != nil {
				log.Println(err)
				return err
			}
		}
	}

	// endpoint_counter表
	{
		counter := item.Metric
		if len(item.Tags) > 0 {
			counter = fmt.Sprintf("%s/%s", counter, cutils.SortedTags(item.Tags))
		}

		sqlStr := "INSERT INTO endpoint_counter(endpoint_id,counter,step,type,ts,t_create) VALUES (?,?,?,?,?,now())" + sqlDuplicateString
		ret, err := conn.Exec(sqlStr, endpointId, counter, item.Step, item.DsType, ts)
		if err != nil {
			log.Println(err)
			return err
		}

		_, err = ret.LastInsertId()
		if err != nil {
			log.Println(err)
			return err
		}
	}

	return nil
}
Example #4
0
func BuildCommonMailContent(event *model.Event) string {
	link := g.Link(event)
	tdtl := `style="border: 1px solid #ccc; background: #FFF4F4;"`
	tdtr := `style="border: 1px solid #ccc; border-left: none;"`
	tdl := `style="border: 1px solid #ccc; border-top:  none; background: #FFF4F4;"`
	tdr := `style="border: 1px solid #ccc; border-top:  none; border-left: none;"`
	return fmt.Sprintf(
		`<html><head><meta charset="utf-8"></head>
		<body>
			<table border="0" cellpadding="5" cellspacing="0">
                                <tr>
                                        <td %s >%s&nbsp;</td>
                                        <td %s >%d&nbsp;</td></tr>
                                <tr>
                                        <td %s>Endpoint:</td>
                                        <td %s>%s&nbsp;</td>
                                </tr>
                                <tr>
                                        <td %s>Metric:</td>
                                        <td %s>%s&nbsp;</td>
                                </tr>
                                <tr>
                                        <td %s>Tags:</td>
                                        <td %s>%s&nbsp;</td>
                                </tr>
                                <tr>
                                        <td %s>%s</td>
                                        <td %s>%s%s%s&nbsp;</td>
                                </tr>
                                <tr>
                                        <td %s>Note:</td>
                                        <td %s>%s&nbsp;</td>
                                </tr>
                                <tr>
                                        <td %s>Max:</td>
                                        <td %s>%d&nbsp;</td>
                                </tr>
                                <tr>
                                        <td %s>Current:</td>
                                        <td %s>%d&nbsp;</td>
                                </tr>
                                <tr>
                                        <td %s>Timesramp:</td>
                                        <td %s>%s&nbsp;</td>
                                </tr>
                        </table>
			<br>
			<a href="%s">%s</a>
		</body></html>`,

		tdtl, event.Status, tdtr, event.Priority(),
		tdl, tdr, event.Endpoint,
		tdl, tdr, event.Metric(),
		tdl, tdr, utils.SortedTags(event.PushedTags),
		tdl, event.Func(), tdr, utils.ReadableFloat(event.LeftValue), event.Operator(), utils.ReadableFloat(event.RightValue()),
		tdl, tdr, event.Note(),
		tdl, tdr, event.MaxStep(),
		tdl, tdr, event.CurrentStep,
		tdl, tdr, event.FormattedTime(),
		link,
		link,
	)
}
Example #5
0
func maybeUpdateIndexFromOneItem(item *cmodel.GraphItem, conn *sql.DB) error {
	if item == nil {
		return nil
	}

	endpoint := item.Endpoint
	ts := item.Timestamp
	var endpointId int64 = -1
	sqlDuplicateString := " ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id), ts=VALUES(ts)" //第一个字符是空格

	// endpoint表
	{
		err := conn.QueryRow("SELECT id FROM endpoint WHERE endpoint = ?", endpoint).Scan(&endpointId)
		if err != nil && err != sql.ErrNoRows {
			log.Println(endpoint, err)
			return err
		}
		proc.IndexUpdateIncrDbEndpointSelectCnt.Incr()

		if err == sql.ErrNoRows || endpointId <= 0 { // 数据库中也没有, insert
			sqlStr := "INSERT INTO endpoint(endpoint, ts, t_create) VALUES (?, ?, now())" + sqlDuplicateString
			ret, err := conn.Exec(sqlStr, endpoint, ts)
			if err != nil {
				log.Println(err)
				return err
			}
			proc.IndexUpdateIncrDbEndpointInsertCnt.Incr()

			endpointId, err = ret.LastInsertId()
			if err != nil {
				log.Println(err)
				return err
			}
		} else { // do not update
		}
		// 更新缓存
		//dbEndpointCache.Set(endpoint, endpointId, 0)
	}

	// tag_endpoint表
	{
		for tagKey, tagVal := range item.Tags {
			tag := fmt.Sprintf("%s=%s", tagKey, tagVal)

			var tagEndpointId int64 = -1
			err := conn.QueryRow("SELECT id FROM tag_endpoint WHERE tag = ? and endpoint_id = ?",
				tag, endpointId).Scan(&tagEndpointId)
			if err != nil && err != sql.ErrNoRows {
				log.Println(tag, endpointId, err)
				return err
			}
			proc.IndexUpdateIncrDbTagEndpointSelectCnt.Incr()

			if err == sql.ErrNoRows || tagEndpointId <= 0 {
				sqlStr := "INSERT INTO tag_endpoint(tag, endpoint_id, ts, t_create) VALUES (?, ?, ?, now())" + sqlDuplicateString
				ret, err := conn.Exec(sqlStr, tag, endpointId, ts)
				if err != nil {
					log.Println(err)
					return err
				}
				proc.IndexUpdateIncrDbTagEndpointInsertCnt.Incr()

				tagEndpointId, err = ret.LastInsertId()
				if err != nil {
					log.Println(err)
					return err
				}
			}
		}
	}

	// endpoint_counter表
	{
		counter := item.Metric
		if len(item.Tags) > 0 {
			counter = fmt.Sprintf("%s/%s", counter, cutils.SortedTags(item.Tags))
		}

		var endpointCounterId int64 = -1
		var step int = 0
		var dstype string = "nil"

		err := conn.QueryRow("SELECT id,step,type FROM endpoint_counter WHERE endpoint_id = ? and counter = ?",
			endpointId, counter).Scan(&endpointCounterId, &step, &dstype)
		if err != nil && err != sql.ErrNoRows {
			log.Println(counter, endpointId, err)
			return err
		}
		proc.IndexUpdateIncrDbEndpointCounterSelectCnt.Incr()

		if err == sql.ErrNoRows || endpointCounterId <= 0 {
			sqlStr := "INSERT INTO endpoint_counter(endpoint_id,counter,step,type,ts,t_create) VALUES (?,?,?,?,?,now())" +
				" ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id),ts=VALUES(ts), step=VALUES(step),type=VALUES(type)"
			ret, err := conn.Exec(sqlStr, endpointId, counter, item.Step, item.DsType, ts)
			if err != nil {
				log.Println(err)
				return err
			}
			proc.IndexUpdateIncrDbEndpointCounterInsertCnt.Incr()

			endpointCounterId, err = ret.LastInsertId()
			if err != nil {
				log.Println(err)
				return err
			}
		} else {
			if !(item.Step == step && item.DsType == dstype) {
				_, err := conn.Exec("UPDATE endpoint_counter SET step = ?, type = ? where id = ?",
					item.Step, item.DsType, endpointCounterId)
				proc.IndexUpdateIncrDbEndpointCounterUpdateCnt.Incr()
				if err != nil {
					log.Println(err)
					return err
				}
			}
		}
	}

	return nil
}
Example #6
0
func InsertEvent(eve *coommonModel.Event) {
	log := logger.Logger()
	q := orm.NewOrm()
	q.Using("falcon_portal")
	var event []EventCases
	q.Raw("select * from event_cases where id = ?", eve.Id).QueryRows(&event)
	if len(event) == 0 {
		//create cases
		sqltemplete := `INSERT INTO event_cases (
					id,
					endpoint,
					metric,
					func,
					cond,
					note,
					max_step,
					current_step,
					priority,
					status,
					timestamp,
					update_at,
					tpl_creator,
					expression_id,
					strategy_id,
					template_id
					) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
		res1, err := q.Raw(
			sqltemplete,
			eve.Id,
			eve.Endpoint,
			counterGen(eve.Metric(), utils.SortedTags(eve.PushedTags)),
			eve.Func(),
			//cond
			fmt.Sprintf("%v %v %v", eve.LeftValue, eve.Operator(), eve.RightValue()),
			eve.Strategy.Note,
			eve.MaxStep(),
			eve.CurrentStep,
			eve.Priority(),
			eve.Status,
			//start_at
			time.Unix(eve.EventTime, 0),
			//update_at
			time.Unix(eve.EventTime, 0),
			eve.Strategy.Tpl.Creator,
			eve.ExpressionId(),
			eve.StrategyId(),
			//template_id
			eve.TplId()).Exec()
		log.Debug(fmt.Sprintf("%v, %v", res1, err))

		//insert case
		res2, err := insertEvent(q, eve)
		log.Debug(fmt.Sprintf("%v, %v", res2, err))

	} else {
		sqltemplete := `UPDATE event_cases SET
				update_at = ?,
				max_step = ?,
				current_step = ?,
				note = ?,
				cond = ?,
				status = ?`
		//reopen case
		if event[0].ProcessStatus == "resolved" || event[0].ProcessStatus == "ignored" {
			sqltemplete = fmt.Sprintf("%v ,process_status = '%s', process_note = %d", sqltemplete, "unresolved", 0)
		}
		if eve.CurrentStep == 1 {

			sqltemplete = fmt.Sprintf("%v ,timestamp = ? WHERE id = ?", sqltemplete)
			//update start time of cases
			res1, err := q.Raw(
				sqltemplete,
				time.Unix(eve.EventTime, 0),
				eve.MaxStep(),
				eve.CurrentStep,
				eve.Strategy.Note,
				fmt.Sprintf("%v %v %v", eve.LeftValue, eve.Operator(), eve.RightValue()),
				eve.Status,
				time.Unix(eve.EventTime, 0),
				eve.Id).Exec()
			log.Debug(fmt.Sprintf("%v, %v", res1, err))
			//insert case
			res2, err := insertEvent(q, eve)
			log.Debug(fmt.Sprintf("%v, %v", res2, err))
		} else {
			sqltemplete = fmt.Sprintf("%v WHERE id = ?", sqltemplete)
			res1, err := q.Raw(
				sqltemplete,
				time.Unix(eve.EventTime, 0),
				eve.MaxStep(),
				eve.CurrentStep,
				eve.Strategy.Note,
				fmt.Sprintf("%v %v %v", eve.LeftValue, eve.Operator(), eve.RightValue()),
				eve.Status,
				eve.Id).Exec()
			log.Debug(fmt.Sprintf("%v, %v", res1, err))
			//insert case
			res2, err := insertEvent(q, eve)
			log.Debug(fmt.Sprintf("%v, %v", res2, err))
		}
	}
}