Пример #1
0
func StatLock(onlyCmd bool, setWindow bool) {

	result := statThreadID()

	start := time.Unix(0, 0)
	end := time.Now().Add(24 * time.Hour)

	w := new(tabwriter.Writer)
	w.Init(os.Stdout, 20, 0, 2, ' ', tabwriter.AlignRight)

	fmt.Fprintln(w, "Time\tTID\tWait\tTill\tCommand\tStart\tEnd\tDuration\t")

	for _, stat := range result {

		if onlyCmd && stat.rcmd == nil {
			continue
		}

		max := stat.r.NextByThread.Time.Sub(stat.r.Time)

		cmd := "nil"
		cmdTime := "nil"
		if stat.rcmd != nil {
			cmdTime = stat.rcmd.Time.Format(utils.DateFormat)
			cmd = stat.rcmd.Cmd
		}

		cmdCompleteTime := "nil"
		if stat.rcmdCompleted != nil {
			cmdCompleteTime = stat.rcmdCompleted.Time.Format(utils.DateFormat)
		}

		duration := ""
		if stat.rcmdCompleted != nil && stat.rcmd != nil {
			duration = fmt.Sprintf("%f", stat.rcmdCompleted.Time.Sub(stat.rcmd.Time).Seconds())
		}

		if stat.r.Time.After(start) {
			start = stat.r.Time
		}

		if stat.r.NextByThread.Time.After(end) {
			end = stat.r.NextByThread.Time
		}

		fmt.Fprintf(w, "%s\t%s\t%f\t%s\t%s\t%s\t%s\t%s\t\n", stat.r.Time.Format(utils.DateFormat), stat.tid, max.Seconds(), stat.r.NextByThread.Time.Format(utils.DateFormat), cmd, cmdTime, cmdCompleteTime, duration)

		if setWindow {
			window.Reset()
			window.SetStart(start)
			window.SetEnd(end)
		}

	}
	fmt.Fprintln(w)
	w.Flush()

}
Пример #2
0
func main() {

	args := os.Args[1:]

	chanThreadID := make(chan *record.Record)
	chanTime := make(chan *record.Record)

	var wg sync.WaitGroup

	wg.Add(2)
	go func() {
		defer wg.Done()
		record.ScanThreadID(chanThreadID)
	}()
	go func() {
		defer wg.Done()
		window.ScanTime(chanTime)
	}()

	for _, files := range args {
		for s := range readLine(files) {
			r := record.NewRecord(s)
			if r != nil {
				chanThreadID <- r
				chanTime <- r
			}
		}
	}

	close(chanThreadID)
	close(chanTime)

	wg.Wait()

	shell.Register("setTime", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("set the time around which the log exploration should be done.\nTo retrieve logs and on going commands.\nSyntax: setTime " + utils.DateFormat)
			return "", nil
		}

		t, err := time.Parse(utils.DateFormat, line)
		if err != nil {
			return "", err
		}

		if err := window.SetTime(t); err != nil {
			return "", err
		}

		rt.SetTime(t)

		return "", nil
	})

	shell.Register("TID", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Show the number of command executed by each thread.\nSyntax: TID")
			return "", nil
		}

		TID.StatTID()
		return "", nil
	})

	shell.Register("log", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Display nbLine log lines around the time that was set (setTime) for a given TID.\nSyntax: log TID [nbLine=5]")
			fmt.Println("Display the log of the command for the time that was set (setTime) for a given TID.\nSyntax: log TID cmd")
			return "", nil
		}

		if len(args) < 1 {
			fmt.Println("Syntax error, missing arguments")
			fmt.Println("Display the log around the time that was set (setTime).\nSyntax: log TID [nbLine=5]")
			return "", nil
		}

		count := 0
		if len(args) == 2 {
			if c, err := strconv.Atoi(args[1]); err == nil {
				count = c
			} else if args[1] == "cmd" {
				count = -1
			}
		}

		logging.GetLog(args[0], count)
		return "", nil
	})

	shell.Register("queue", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Build statistic for queues (readonly pool or write).\nSyntax: queue [r|w]")
			return "", nil
		}

		queue.StatQueue(len(args) > 0 && args[0] == "w")
		return "", nil
	})

	shell.Register("cmd", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Show the commands statistics.\nSyntax: cmd")
			fmt.Println("Show the commands for a given thread in the time window.\nSyntax: cmd 'TID'")
			fmt.Println("Show the response time distribution in the time window.\nSyntax: cmd d 'CmdName'")
			return "", nil
		}

		if len(args) == 1 {
			if _, err := strconv.Atoi(args[0]); err == nil {
				cmd.StatCmdTID(args[0])
				return "", nil
			}
		}

		if len(args) == 2 {
			if args[0] == "d" {
				cmd.StatCmdDistribution(args[1])
				return "", nil
			}
		}

		cmd.StatCmdAll()

		return "", nil
	})

	shell.Register("lock", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Search for each thread the max hang time.\nSyntax: lock [cmd] [setWindow]\n\tcmd: Only display the theard that execute commands\n\tsetWindow: set the time window to the range of time returned by this lock exploration.")
			return "", nil
		}

		onlyCmd := false
		setWindow := false
		for _, a := range args {
			if a == "cmd" {
				onlyCmd = true
			}
			if a == "setWindow" {
				setWindow = true
			}
		}

		lock.StatLock(onlyCmd, setWindow)

		if setWindow {
			updatePromt()
		}

		return "", nil
	})

	shell.Register("window", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Display the time window of all the logs and the enclosed one used for the statistics.\nSyntax: window [reset]\n\treset: set the active window to the maximum (all logs)")
			return "", nil
		}

		if len(args) > 0 && args[0] == "reset" {
			window.Reset()
			updatePromt()
		}

		return window.GetWindow().Print(), nil
	})

	shell.Register("start", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Set the lower bound of the active time window.\nSyntax: start " + utils.DateFormat)
			return "", nil
		}

		if len(args) == 0 {
			return "", fmt.Errorf("start take 1 argument that must be a timestamp")
		}

		start, err := time.Parse(utils.DateFormat, strings.Join(args, " "))

		if err != nil {
			return "", err
		}
		if err = window.SetStart(start); err != nil {
			return "", err
		}
		updatePromt()

		return "", nil
	})

	shell.Register("end", func(args ...string) (string, error) {
		line := strings.Join(args, " ")
		if strings.Contains(line, "--help") {
			fmt.Println("Set the upper bound of the active time window.\nSyntax: end " + utils.DateFormat)
			return "", nil
		}

		if len(args) == 0 {
			return "", fmt.Errorf("start take 1 argument that must be a timestamp")
		}

		start, err := time.Parse(utils.DateFormat, strings.Join(args, " "))

		if err != nil {
			return "", err
		}
		if err = window.SetEnd(start); err != nil {
			return "", err
		}
		updatePromt()

		return "", nil
	})

	updatePromt()

	shell.Start()

}