diff --git a/README.md b/README.md
index c2ac5b3..d116a55 100644
--- a/README.md
+++ b/README.md
@@ -93,6 +93,7 @@ Measurement Commands:
 Additional Commands:
   completion    Generate the autocompletion script for the specified shell
   help          Help about any command
+  history       Show the history of your measurements in your current session
   install-probe Join the community powered Globalping platform by running a Docker container.
   version       Print the version number of Globalping CLI
 
@@ -307,6 +308,24 @@ Madrid, ES, EU, EDGOO NETWORKS LLC (AS47787)           |   22 |   0.00% |  0.24
 ^C
 ```
 
+#### History
+
+You can view the history of your measurements by running the `history` command.
+
+```bash
+globalping history
+1 | 2024-03-27 11:56:46 | ping google.com
+> https://www.jsdelivr.com/globalping?measurement=itcR65tYCqbouXib
+- | 2024-03-27 11:57:01 | dns google.com from last
+> https://www.jsdelivr.com/globalping?measurement=kWc5UBK9A6G4RUYM
+2 | 2024-03-27 11:57:20 | traceroute google.com from New York --limit 2
+> https://www.jsdelivr.com/globalping?measurement=Yz7A1UifUonZsC3C
+3 | 2024-03-27 11:57:37 | mtr google.com from New York --limit 2
+> https://www.jsdelivr.com/globalping?measurement=SX1NBgfDKiabM1vZ
+4 | 2024-03-27 11:57:52 | http google.com from London,Belgium --limit 2 --method get --ci
+> https://www.jsdelivr.com/globalping?measurement=eclwFSYX0zgU10Cs
+```
+
 #### Learn about available flags
 
 Most commands have shared and unique flags. We recommend that you familiarize yourself with these so that you can run and automate your network tests in powerful ways.
diff --git a/cmd/common.go b/cmd/common.go
index c2f4769..66bbe15 100644
--- a/cmd/common.go
+++ b/cmd/common.go
@@ -19,9 +19,13 @@ import (
 )
 
 var (
-	ErrorNoPreviousMeasurements = errors.New("no previous measurements found")
-	ErrInvalidIndex             = errors.New("invalid index")
-	ErrIndexOutOfRange          = errors.New("index out of range")
+	ErrNoPreviousMeasurements = errors.New("no previous measurements found")
+	ErrInvalidIndex           = errors.New("invalid index")
+	ErrIndexOutOfRange        = errors.New("index out of range")
+)
+var (
+	saveIdToSessionErr = "failed to save measurement ID: %s"
+	readMeasuremetsErr = "failed to read previous measurements: %s"
 )
 
 var SESSION_PATH string
@@ -78,6 +82,7 @@ func (r *Root) getLocations() ([]globalping.Locations, error) {
 		if mId == "" {
 			mId = strings.TrimSpace(fromArr[0])
 		} else {
+			r.ctx.IsLocationFromSession = true
 			r.ctx.RecordToSession = false
 		}
 		return []globalping.Locations{{Magic: mId}}, nil
@@ -182,19 +187,19 @@ func getIdFromSession(index int) (string, error) {
 	f, err := os.Open(getMeasurementsPath())
 	if err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
-			return "", ErrorNoPreviousMeasurements
+			return "", ErrNoPreviousMeasurements
 		}
-		return "", fmt.Errorf("failed to open previous measurements file: %s", err)
+		return "", fmt.Errorf(readMeasuremetsErr, err)
 	}
 	defer f.Close()
 	// Read ids from the end of the file
 	if index < 0 {
 		fStats, err := f.Stat()
 		if err != nil {
-			return "", fmt.Errorf("failed to read previous measurements: %s", err)
+			return "", fmt.Errorf(readMeasuremetsErr, err)
 		}
 		if fStats.Size() == 0 {
-			return "", ErrorNoPreviousMeasurements
+			return "", ErrNoPreviousMeasurements
 		}
 		scanner := backscanner.New(f, int(fStats.Size()-1)) // -1 to skip last newline
 		for {
@@ -204,7 +209,7 @@ func getIdFromSession(index int) (string, error) {
 				if err == io.EOF {
 					return "", ErrIndexOutOfRange
 				}
-				return "", fmt.Errorf("failed to read previous measurements: %s", err)
+				return "", fmt.Errorf(readMeasuremetsErr, err)
 			}
 			if index == 0 {
 				return string(b), nil
@@ -232,20 +237,20 @@ func saveIdToSession(id string) error {
 		if errors.Is(err, fs.ErrNotExist) {
 			err := os.Mkdir(getSessionPath(), 0755)
 			if err != nil {
-				return fmt.Errorf("failed to save measurement ID: %s", err)
+				return fmt.Errorf(saveIdToSessionErr, err)
 			}
 		} else {
-			return fmt.Errorf("failed to save measurement ID: %s", err)
+			return fmt.Errorf(saveIdToSessionErr, err)
 		}
 	}
 	f, err := os.OpenFile(getMeasurementsPath(), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
-		return fmt.Errorf("failed to save measurement ID: %s", err)
+		return fmt.Errorf(saveIdToSessionErr, err)
 	}
 	defer f.Close()
 	_, err = f.WriteString(id + "\n")
 	if err != nil {
-		return fmt.Errorf("failed to save measurement ID: %s", err)
+		return fmt.Errorf(saveIdToSessionErr, err)
 	}
 	return nil
 }
@@ -282,3 +287,7 @@ func getSessionId() string {
 func getMeasurementsPath() string {
 	return filepath.Join(getSessionPath(), "measurements")
 }
+
+func getHistoryPath() string {
+	return filepath.Join(getSessionPath(), "history")
+}
diff --git a/cmd/common_test.go b/cmd/common_test.go
index e295799..06d5be6 100644
--- a/cmd/common_test.go
+++ b/cmd/common_test.go
@@ -23,7 +23,7 @@ func Test_UpdateContext(t *testing.T) {
 }
 
 func test_updateContext_NoArg(t *testing.T) {
-	ctx := &view.Context{}
+	ctx := createDefaultContext("ping")
 	printer := view.NewPrinter(nil, nil, nil)
 	root := NewRoot(printer, ctx, nil, nil, nil, nil)
 
@@ -35,7 +35,7 @@ func test_updateContext_NoArg(t *testing.T) {
 }
 
 func test_updateContext_Country(t *testing.T) {
-	ctx := &view.Context{}
+	ctx := createDefaultContext("ping")
 	printer := view.NewPrinter(nil, nil, nil)
 	root := NewRoot(printer, ctx, nil, nil, nil, nil)
 
@@ -48,7 +48,7 @@ func test_updateContext_Country(t *testing.T) {
 
 // Check if country with whitespace is parsed correctly
 func test_updateContext_CountryWhitespace(t *testing.T) {
-	ctx := &view.Context{}
+	ctx := createDefaultContext("ping")
 	printer := view.NewPrinter(nil, nil, nil)
 	root := NewRoot(printer, ctx, nil, nil, nil, nil)
 
@@ -60,7 +60,7 @@ func test_updateContext_CountryWhitespace(t *testing.T) {
 }
 
 func test_updateContext_NoTarget(t *testing.T) {
-	ctx := &view.Context{}
+	ctx := createDefaultContext("ping")
 	printer := view.NewPrinter(nil, nil, nil)
 	root := NewRoot(printer, ctx, nil, nil, nil, nil)
 
@@ -73,7 +73,7 @@ func test_uodateContext_CIEnv(t *testing.T) {
 	t.Setenv("CI", "true")
 	defer t.Setenv("CI", oldCI)
 
-	ctx := &view.Context{}
+	ctx := createDefaultContext("ping")
 	printer := view.NewPrinter(nil, nil, nil)
 	root := NewRoot(printer, ctx, nil, nil, nil, nil)
 
diff --git a/cmd/dns.go b/cmd/dns.go
index ebc0c7e..9053d1a 100644
--- a/cmd/dns.go
+++ b/cmd/dns.go
@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"github.com/jsdelivr/globalping-cli/globalping"
+	"github.com/jsdelivr/globalping-cli/view"
 	"github.com/spf13/cobra"
 )
 
@@ -53,11 +54,11 @@ Using the dig format @resolver. For example:
 
 	// dns specific flags
 	flags := dnsCmd.Flags()
-	flags.StringVar(&r.ctx.Protocol, "protocol", "", "Specifies the protocol to use for the DNS query (TCP or UDP) (default \"udp\")")
-	flags.IntVar(&r.ctx.Port, "port", 0, "Send the query to a non-standard port on the server (default 53)")
-	flags.StringVar(&r.ctx.Resolver, "resolver", "", "Resolver is the hostname or IP address of the name server to use (default empty)")
-	flags.StringVar(&r.ctx.QueryType, "type", "", "Specifies the type of DNS query to perform (default \"A\")")
-	flags.BoolVar(&r.ctx.Trace, "trace", false, "Toggle tracing of the delegation path from the root name servers (default false)")
+	flags.StringVar(&r.ctx.Protocol, "protocol", r.ctx.Protocol, "Specifies the protocol to use for the DNS query (TCP or UDP) (default \"udp\")")
+	flags.IntVar(&r.ctx.Port, "port", r.ctx.Port, "Send the query to a non-standard port on the server (default 53)")
+	flags.StringVar(&r.ctx.Resolver, "resolver", r.ctx.Resolver, "Resolver is the hostname or IP address of the name server to use (default empty)")
+	flags.StringVar(&r.ctx.QueryType, "type", r.ctx.QueryType, "Specifies the type of DNS query to perform (default \"A\")")
+	flags.BoolVar(&r.ctx.Trace, "trace", r.ctx.Trace, "Toggle tracing of the delegation path from the root name servers (default false)")
 
 	r.Cmd.AddCommand(dnsCmd)
 }
@@ -68,6 +69,7 @@ func (r *Root) RunDNS(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	defer r.UpdateHistory()
 	r.ctx.RecordToSession = true
 
 	opts := &globalping.MeasurementCreate{
@@ -100,7 +102,12 @@ func (r *Root) RunDNS(cmd *cobra.Command, args []string) error {
 	}
 
 	r.ctx.MeasurementsCreated++
-
+	hm := &view.HistoryItem{
+		Id:        res.ID,
+		Status:    globalping.StatusInProgress,
+		StartedAt: r.time.Now(),
+	}
+	r.ctx.History.Push(hm)
 	if r.ctx.RecordToSession {
 		r.ctx.RecordToSession = false
 		err := saveIdToSession(res.ID)
diff --git a/cmd/dns_test.go b/cmd/dns_test.go
index e5b0baa..870c259 100644
--- a/cmd/dns_test.go
+++ b/cmd/dns_test.go
@@ -37,10 +37,13 @@ func Test_Execute_DNS_Default(t *testing.T) {
 	viewerMock := mocks.NewMockViewer(ctrl)
 	viewerMock.EXPECT().Output(measurementID1, expectedOpts).Times(1).Return(nil)
 
+	timeMock := mocks.NewMockTime(ctrl)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
+
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(nil, w, w)
-	ctx := createDefaultContext()
-	root := NewRoot(printer, ctx, viewerMock, nil, gbMock, nil)
+	ctx := createDefaultContext("dns")
+	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 
 	os.Args = []string{"globalping", "dns", "jsdelivr.com",
 		"from", "Berlin",
@@ -67,6 +70,15 @@ func Test_Execute_DNS_Default(t *testing.T) {
 
 	b, err := os.ReadFile(getMeasurementsPath())
 	assert.NoError(t, err)
-	expectedHistory := []byte(measurementID1 + "\n")
-	assert.Equal(t, expectedHistory, b)
+	expectedHistory := measurementID1 + "\n"
+	assert.Equal(t, expectedHistory, string(b))
+
+	b, err = os.ReadFile(getHistoryPath())
+	assert.NoError(t, err)
+	expectedHistory = createDefaultExpectedHistoryLogItem(
+		"1",
+		measurementID1,
+		"dns jsdelivr.com from Berlin --limit 2 --type MX --resolver 1.1.1.1 --port 99 --protocol tcp --trace",
+	)
+	assert.Equal(t, expectedHistory, string(b))
 }
diff --git a/cmd/history.go b/cmd/history.go
new file mode 100644
index 0000000..e19534a
--- /dev/null
+++ b/cmd/history.go
@@ -0,0 +1,246 @@
+package cmd
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/icza/backscanner"
+	"github.com/jsdelivr/globalping-cli/view"
+	"github.com/spf13/cobra"
+)
+
+var (
+	ErrReadHistory = errors.New("failed to read history")
+)
+
+var (
+	invalidHistoryItemErr = "invalid history item: %s"
+	saveToHistoryErr      = "failed to save to history: %s"
+)
+
+const (
+	// <version>|<index>|<time>|<id>|<command>
+	HistoryItemVersion1 string = "1"
+)
+
+func (r *Root) initHistory() {
+	historyCmd := &cobra.Command{
+		Run:   r.RunHistory,
+		Use:   "history",
+		Short: "Show the history of your measurements in your current session",
+		Long: `Show the history of your measurements in your current session
+Examples:
+  # Show all the measurements
+  history
+
+  # Show the first 5 measurements
+  history --head 5
+
+  # Show the last 10 measurements
+  history --tail 10`,
+	}
+
+	flags := historyCmd.Flags()
+	flags.UintVar(&r.ctx.Head, "head", r.ctx.Head, "Number of measurements to show from the beginning of the history")
+	flags.UintVar(&r.ctx.Tail, "tail", r.ctx.Tail, "Number of measurements to show from the end of the history")
+
+	r.Cmd.AddCommand(historyCmd)
+}
+
+func (r *Root) RunHistory(cmd *cobra.Command, args []string) {
+	var limit int = 0
+	if r.ctx.Head > 0 {
+		limit = int(r.ctx.Head)
+	} else if r.ctx.Tail > 0 {
+		limit = -int(r.ctx.Tail)
+	}
+	items, err := r.GetHistory(limit)
+	if err != nil {
+		r.printer.Println(err)
+		return
+	}
+	if len(items) == 0 {
+		r.printer.Println("No history items found")
+		return
+	}
+	for _, item := range items {
+		r.printer.Println(item)
+	}
+}
+
+func (r *Root) UpdateHistory() error {
+	ids := r.ctx.History.ToString("+")
+	if ids == "" {
+		return nil
+	}
+	_, err := os.Stat(getSessionPath())
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			err := os.Mkdir(getSessionPath(), 0755)
+			if err != nil {
+				return fmt.Errorf(saveToHistoryErr, err)
+			}
+		} else {
+			return fmt.Errorf(saveToHistoryErr, err)
+		}
+	}
+	index := "-"
+	if !r.ctx.IsLocationFromSession {
+		i, err := getIndex()
+		if err != nil {
+			return err
+		}
+		index = fmt.Sprintf("%d", i)
+	}
+	time := r.time.Now().Unix()
+	cmd := strings.Join(os.Args[1:], " ")
+	f, err := os.OpenFile(getHistoryPath(), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf(saveToHistoryErr, err)
+	}
+	defer f.Close()
+	_, err = f.WriteString(fmt.Sprintf("%s|%s|%d|%s|%s\n", HistoryItemVersion1, index, time, ids, cmd))
+	if err != nil {
+		return fmt.Errorf(saveToHistoryErr, err)
+	}
+	return nil
+}
+
+func (r *Root) GetHistory(limit int) ([]string, error) {
+	items := make([]string, 0)
+	f, err := os.Open(getHistoryPath())
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return items, nil
+		}
+		return nil, ErrReadHistory
+	}
+	defer f.Close()
+	// Read from the end of the file
+	if limit < 0 {
+		fStats, err := f.Stat()
+		if err != nil {
+			return nil, ErrReadHistory
+		}
+		if fStats.Size() == 0 {
+			return items, nil
+		}
+		scanner := backscanner.New(f, int(fStats.Size()-1)) // -1 to skip last newline
+		for {
+			limit++
+			b, _, err := scanner.LineBytes()
+			if err != nil {
+				if err == io.EOF {
+					return items, nil
+				}
+				return nil, ErrReadHistory
+			}
+			item, err := parseHistoryItem(string(b))
+			if err != nil {
+				return nil, err
+			}
+			items = append(items, item)
+			if limit == 0 {
+				break
+			}
+		}
+		return items, nil
+	}
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		limit--
+		item, err := parseHistoryItem(scanner.Text())
+		if err != nil {
+			return nil, err
+		}
+		items = append(items, item)
+		if limit == 0 {
+			break
+		}
+	}
+	return items, nil
+}
+
+func parseHistoryItem(line string) (string, error) {
+	parts, err := getHistoryItem(line)
+	if err != nil {
+		return "", err
+	}
+	if parts[0] == HistoryItemVersion1 {
+		t, err := strconv.ParseInt(parts[2], 10, 64)
+		if err != nil {
+			return "", fmt.Errorf(invalidHistoryItemErr, line)
+		}
+		return fmt.Sprintf(
+			"%s | %s | %s\n%s",
+			parts[1],
+			time.Unix(t, 0).Format("2006-01-02 15:04:05"),
+			parts[4],
+			"> "+view.ShareURL+parts[3],
+		), nil
+	}
+	return "", nil
+}
+
+func getHistoryItem(line string) ([]string, error) {
+	parts := strings.Split(line, "|")
+	if len(parts) < 1 {
+		return nil, fmt.Errorf(invalidHistoryItemErr, line)
+	}
+	switch parts[0] {
+	case HistoryItemVersion1:
+		if len(parts) != 5 {
+			return nil, fmt.Errorf(invalidHistoryItemErr, line)
+		}
+		return parts, nil
+	default:
+		return nil, fmt.Errorf(invalidHistoryItemErr, line)
+	}
+}
+
+func getIndex() (int, error) {
+	f, err := os.Open(getHistoryPath())
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return 1, nil
+		}
+		return 0, ErrReadHistory
+	}
+	defer f.Close()
+	fStats, err := f.Stat()
+	if err != nil {
+		return 0, ErrReadHistory
+	}
+	if fStats.Size() == 0 {
+		return 1, nil
+	}
+	scanner := backscanner.New(f, int(fStats.Size()-1)) // -1 to skip last newline
+	for {
+		b, _, err := scanner.LineBytes()
+		if err != nil {
+			if err == io.EOF {
+				return 1, nil
+			}
+			return 0, ErrReadHistory
+		}
+		parts, err := getHistoryItem(string(b))
+		if err != nil {
+			return 0, err
+		}
+		if parts[1] == "-" {
+			continue
+		}
+		index, err := strconv.Atoi(parts[1])
+		if err != nil {
+			return 0, err
+		}
+		return index + 1, nil
+	}
+}
diff --git a/cmd/history_test.go b/cmd/history_test.go
new file mode 100644
index 0000000..3d7b477
--- /dev/null
+++ b/cmd/history_test.go
@@ -0,0 +1,91 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jsdelivr/globalping-cli/globalping"
+	"github.com/jsdelivr/globalping-cli/mocks"
+	"github.com/jsdelivr/globalping-cli/view"
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/mock/gomock"
+)
+
+func Test_Execute_History_Default(t *testing.T) {
+	t.Cleanup(sessionCleanup)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	timeMock := mocks.NewMockTime(ctrl)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
+
+	ctx := createDefaultContext("ping")
+	w := new(bytes.Buffer)
+	printer := view.NewPrinter(nil, w, w)
+	root := NewRoot(printer, ctx, nil, timeMock, nil, nil)
+	os.Args = []string{"globalping", "ping", "jsdelivr.com"}
+
+	ctx.History.Push(&view.HistoryItem{
+		Id:        measurementID1,
+		Status:    globalping.StatusInProgress,
+		StartedAt: defaultCurrentTime,
+	})
+	root.UpdateHistory()
+
+	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "last"}
+	ctx.IsLocationFromSession = true
+	ctx.History.Push(&view.HistoryItem{
+		Id:        measurementID2,
+		Status:    globalping.StatusInProgress,
+		StartedAt: defaultCurrentTime,
+	})
+	root.UpdateHistory()
+
+	os.Args = []string{"globalping", "ping", "jsdelivr.com"}
+	ctx.IsLocationFromSession = false
+	root.UpdateHistory()
+	root.UpdateHistory()
+	root.UpdateHistory()
+	ctx.History.Push(&view.HistoryItem{
+		Id:        measurementID3,
+		Status:    globalping.StatusInProgress,
+		StartedAt: defaultCurrentTime,
+	})
+	root.UpdateHistory()
+
+	os.Args = []string{"globalping", "history"}
+	err := root.Cmd.ExecuteContext(context.TODO())
+	assert.NoError(t, err)
+
+	timeStr := time.Unix(defaultCurrentTime.Unix(), 0).Format("2006-01-02 15:04:05")
+	assert.Equal(t,
+		createDefaultExpectedHistoryItem("1", timeStr, "ping jsdelivr.com", measurementID1)+
+			createDefaultExpectedHistoryItem("-", timeStr, "ping jsdelivr.com from last", measurementID2)+
+			createDefaultExpectedHistoryItem("2", timeStr, "ping jsdelivr.com", measurementID2)+
+			createDefaultExpectedHistoryItem("3", timeStr, "ping jsdelivr.com", measurementID2)+
+			createDefaultExpectedHistoryItem("4", timeStr, "ping jsdelivr.com", measurementID2)+
+			createDefaultExpectedHistoryItem("5", timeStr, "ping jsdelivr.com", measurementID3),
+		w.String())
+
+	w.Reset()
+	os.Args = []string{"globalping", "history", "--tail", "2"}
+	err = root.Cmd.ExecuteContext(context.TODO())
+	assert.NoError(t, err)
+	assert.Equal(t,
+		createDefaultExpectedHistoryItem("5", timeStr, "ping jsdelivr.com", measurementID3)+
+			createDefaultExpectedHistoryItem("4", timeStr, "ping jsdelivr.com", measurementID2),
+		w.String())
+
+	w.Reset()
+	os.Args = []string{"globalping", "history", "--head", "2"}
+	err = root.Cmd.ExecuteContext(context.TODO())
+	assert.NoError(t, err)
+	assert.Equal(t,
+		createDefaultExpectedHistoryItem("1", timeStr, "ping jsdelivr.com", measurementID1)+
+			createDefaultExpectedHistoryItem("-", timeStr, "ping jsdelivr.com from last", measurementID2),
+		w.String())
+}
diff --git a/cmd/http.go b/cmd/http.go
index f4b2997..17130bc 100644
--- a/cmd/http.go
+++ b/cmd/http.go
@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/jsdelivr/globalping-cli/globalping"
+	"github.com/jsdelivr/globalping-cli/view"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
@@ -68,15 +69,15 @@ Examples:
 
 	// http specific flags
 	flags := httpCmd.Flags()
-	flags.StringVar(&r.ctx.Protocol, "protocol", "", "Specifies the query protocol (HTTP, HTTPS, HTTP2) (default \"HTTP\")")
-	flags.IntVar(&r.ctx.Port, "port", 0, "Specifies the port to use (default 80 for HTTP, 443 for HTTPS and HTTP2)")
-	flags.StringVar(&r.ctx.Resolver, "resolver", "", "Specifies the resolver server used for DNS lookup (default is defined by the probe's network)")
-	flags.StringVar(&r.ctx.Host, "host", "", "Specifies the Host header, which is going to be added to the request (default host defined in target)")
-	flags.StringVar(&r.ctx.Path, "path", "", "A URL pathname (default \"/\")")
-	flags.StringVar(&r.ctx.Query, "query", "", "A query-string")
-	flags.StringVar(&r.ctx.Method, "method", "", "Specifies the HTTP method to use (HEAD or GET) (default \"HEAD\")")
-	flags.StringArrayVarP(&r.ctx.Headers, "header", "H", nil, "Specifies a HTTP header to be added to the request, in the format \"Key: Value\". Multiple headers can be added by adding multiple flags")
-	flags.BoolVar(&r.ctx.Full, "full", false, "Full output. Uses an HTTP GET request, and outputs the status, headers and body to the output")
+	flags.StringVar(&r.ctx.Protocol, "protocol", r.ctx.Protocol, "Specifies the query protocol (HTTP, HTTPS, HTTP2) (default \"HTTP\")")
+	flags.IntVar(&r.ctx.Port, "port", r.ctx.Port, "Specifies the port to use (default 80 for HTTP, 443 for HTTPS and HTTP2)")
+	flags.StringVar(&r.ctx.Resolver, "resolver", r.ctx.Resolver, "Specifies the resolver server used for DNS lookup (default is defined by the probe's network)")
+	flags.StringVar(&r.ctx.Host, "host", r.ctx.Host, "Specifies the Host header, which is going to be added to the request (default host defined in target)")
+	flags.StringVar(&r.ctx.Path, "path", r.ctx.Path, "A URL pathname (default \"/\")")
+	flags.StringVar(&r.ctx.Query, "query", r.ctx.Query, "A query-string")
+	flags.StringVar(&r.ctx.Method, "method", r.ctx.Method, "Specifies the HTTP method to use (HEAD or GET) (default \"HEAD\")")
+	flags.StringArrayVarP(&r.ctx.Headers, "header", "H", r.ctx.Headers, "Specifies a HTTP header to be added to the request, in the format \"Key: Value\". Multiple headers can be added by adding multiple flags")
+	flags.BoolVar(&r.ctx.Full, "full", r.ctx.Full, "Full output. Uses an HTTP GET request, and outputs the status, headers and body to the output")
 
 	r.Cmd.AddCommand(httpCmd)
 }
@@ -87,6 +88,7 @@ func (r *Root) RunHTTP(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	defer r.UpdateHistory()
 	r.ctx.RecordToSession = true
 
 	opts, err := r.buildHttpMeasurementRequest()
@@ -109,7 +111,12 @@ func (r *Root) RunHTTP(cmd *cobra.Command, args []string) error {
 	}
 
 	r.ctx.MeasurementsCreated++
-
+	hm := &view.HistoryItem{
+		Id:        res.ID,
+		Status:    globalping.StatusInProgress,
+		StartedAt: r.time.Now(),
+	}
+	r.ctx.History.Push(hm)
 	if r.ctx.RecordToSession {
 		r.ctx.RecordToSession = false
 		err := saveIdToSession(res.ID)
diff --git a/cmd/http_test.go b/cmd/http_test.go
index bb5c51f..246c951 100644
--- a/cmd/http_test.go
+++ b/cmd/http_test.go
@@ -39,10 +39,13 @@ func Test_Execute_HTTP_Default(t *testing.T) {
 	viewerMock := mocks.NewMockViewer(ctrl)
 	viewerMock.EXPECT().Output(measurementID1, expectedOpts).Times(1).Return(nil)
 
+	timeMock := mocks.NewMockTime(ctrl)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
+
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(nil, w, w)
-	ctx := createDefaultContext()
-	root := NewRoot(printer, ctx, viewerMock, nil, gbMock, nil)
+	ctx := createDefaultContext("http")
+	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "http", "jsdelivr.com",
 		"from", "Berlin",
 		"--protocol", "HTTPS",
@@ -75,8 +78,17 @@ func Test_Execute_HTTP_Default(t *testing.T) {
 
 	b, err := os.ReadFile(getMeasurementsPath())
 	assert.NoError(t, err)
-	expectedHistory := []byte(measurementID1 + "\n")
-	assert.Equal(t, expectedHistory, b)
+	expectedHistory := measurementID1 + "\n"
+	assert.Equal(t, expectedHistory, string(b))
+
+	b, err = os.ReadFile(getHistoryPath())
+	assert.NoError(t, err)
+	expectedHistory = createDefaultExpectedHistoryLogItem(
+		"1",
+		measurementID1,
+		"http jsdelivr.com from Berlin --protocol HTTPS --method GET --host example.com --path /robots.txt --query test=1 --header X-Test: 1 --resolver 1.1.1.1 --port 99 --full",
+	)
+	assert.Equal(t, expectedHistory, string(b))
 }
 
 func Test_ParseUrlData(t *testing.T) {
@@ -151,7 +163,7 @@ func Test_ParseHttpHeaders_Invalid(t *testing.T) {
 }
 
 func Test_BuildHttpMeasurementRequest_Full(t *testing.T) {
-	ctx := &view.Context{}
+	ctx := createDefaultContext("http")
 	printer := view.NewPrinter(nil, nil, nil)
 	root := NewRoot(printer, ctx, nil, nil, nil, nil)
 
@@ -184,7 +196,7 @@ func Test_BuildHttpMeasurementRequest_Full(t *testing.T) {
 }
 
 func Test_BuildHttpMeasurementRequest_HEAD(t *testing.T) {
-	ctx := &view.Context{}
+	ctx := createDefaultContext("http")
 	printer := view.NewPrinter(nil, nil, nil)
 	root := NewRoot(printer, ctx, nil, nil, nil, nil)
 
diff --git a/cmd/install_probe_test.go b/cmd/install_probe_test.go
index 0bba788..bea4321 100644
--- a/cmd/install_probe_test.go
+++ b/cmd/install_probe_test.go
@@ -27,7 +27,7 @@ func Test_Execute_Install_Probe_Docker(t *testing.T) {
 	reader := bytes.NewReader([]byte("Y\n"))
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(reader, w, w)
-	ctx := &view.Context{}
+	ctx := createDefaultContext("install-probe")
 	root := NewRoot(printer, ctx, nil, nil, nil, probeMock)
 	os.Args = []string{"globalping", "install-probe"}
 	err := root.Cmd.ExecuteContext(context.TODO())
@@ -41,8 +41,9 @@ Please confirm to pull and run our Docker container (ghcr.io/jsdelivr/globalping
 `, w.String())
 
 	expectedCtx := &view.Context{
-		From:  "world",
-		Limit: 1,
+		History: view.NewHistoryBuffer(1),
+		From:    "world",
+		Limit:   1,
 	}
 	assert.Equal(t, expectedCtx, ctx)
 }
diff --git a/cmd/mtr.go b/cmd/mtr.go
index 044a196..bdd0126 100644
--- a/cmd/mtr.go
+++ b/cmd/mtr.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/jsdelivr/globalping-cli/globalping"
+	"github.com/jsdelivr/globalping-cli/view"
 	"github.com/spf13/cobra"
 )
 
@@ -43,9 +44,9 @@ Examples:
 
 	// mtr specific flags
 	flags := mtrCmd.Flags()
-	flags.StringVar(&r.ctx.Protocol, "protocol", "", "Specifies the protocol used (ICMP, TCP or UDP) (default \"icmp\")")
-	flags.IntVar(&r.ctx.Port, "port", 0, "Specifies the port to use. Only applicable for TCP protocol (default 53)")
-	flags.IntVar(&r.ctx.Packets, "packets", 0, "Specifies the number of packets to send to each hop (default 3)")
+	flags.StringVar(&r.ctx.Protocol, "protocol", r.ctx.Protocol, "Specifies the protocol used (ICMP, TCP or UDP) (default \"icmp\")")
+	flags.IntVar(&r.ctx.Port, "port", r.ctx.Port, "Specifies the port to use. Only applicable for TCP protocol (default 53)")
+	flags.IntVar(&r.ctx.Packets, "packets", r.ctx.Packets, "Specifies the number of packets to send to each hop (default 3)")
 
 	r.Cmd.AddCommand(mtrCmd)
 }
@@ -60,6 +61,7 @@ func (r *Root) RunMTR(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("the latency flag is not supported by the mtr command")
 	}
 
+	defer r.UpdateHistory()
 	r.ctx.RecordToSession = true
 
 	opts := &globalping.MeasurementCreate{
@@ -88,7 +90,12 @@ func (r *Root) RunMTR(cmd *cobra.Command, args []string) error {
 	}
 
 	r.ctx.MeasurementsCreated++
-
+	hm := &view.HistoryItem{
+		Id:        res.ID,
+		Status:    globalping.StatusInProgress,
+		StartedAt: r.time.Now(),
+	}
+	r.ctx.History.Push(hm)
 	if r.ctx.RecordToSession {
 		r.ctx.RecordToSession = false
 		err := saveIdToSession(res.ID)
diff --git a/cmd/mtr_test.go b/cmd/mtr_test.go
index 604d9c3..5208fb7 100644
--- a/cmd/mtr_test.go
+++ b/cmd/mtr_test.go
@@ -32,10 +32,13 @@ func Test_Execute_MTR_Default(t *testing.T) {
 	viewerMock := mocks.NewMockViewer(ctrl)
 	viewerMock.EXPECT().Output(measurementID1, expectedOpts).Times(1).Return(nil)
 
+	timeMock := mocks.NewMockTime(ctrl)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
+
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(nil, w, w)
-	ctx := createDefaultContext()
-	root := NewRoot(printer, ctx, viewerMock, nil, gbMock, nil)
+	ctx := createDefaultContext("mtr")
+	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "mtr", "jsdelivr.com",
 		"from", "Berlin",
 		"--limit", "2",
@@ -58,6 +61,15 @@ func Test_Execute_MTR_Default(t *testing.T) {
 
 	b, err := os.ReadFile(getMeasurementsPath())
 	assert.NoError(t, err)
-	expectedHistory := []byte(measurementID1 + "\n")
-	assert.Equal(t, expectedHistory, b)
+	expectedHistory := measurementID1 + "\n"
+	assert.Equal(t, expectedHistory, string(b))
+
+	b, err = os.ReadFile(getHistoryPath())
+	assert.NoError(t, err)
+	expectedHistory = createDefaultExpectedHistoryLogItem(
+		"1",
+		measurementID1,
+		"mtr jsdelivr.com from Berlin --limit 2 --protocol tcp --port 99 --packets 16",
+	)
+	assert.Equal(t, expectedHistory, string(b))
 }
diff --git a/cmd/ping.go b/cmd/ping.go
index e553989..bdf5639 100644
--- a/cmd/ping.go
+++ b/cmd/ping.go
@@ -49,8 +49,8 @@ Examples:
 
 	// ping specific flags
 	flags := pingCmd.Flags()
-	flags.IntVar(&r.ctx.Packets, "packets", 0, "Specifies the desired amount of ECHO_REQUEST packets to be sent (default 3)")
-	flags.BoolVar(&r.ctx.Infinite, "infinite", false, "Keep pinging the target continuously until stopped (default false)")
+	flags.IntVar(&r.ctx.Packets, "packets", r.ctx.Packets, "Specifies the desired amount of ECHO_REQUEST packets to be sent (default 3)")
+	flags.BoolVar(&r.ctx.Infinite, "infinite", r.ctx.Infinite, "Keep pinging the target continuously until stopped (default false)")
 
 	r.Cmd.AddCommand(pingCmd)
 }
@@ -61,6 +61,7 @@ func (r *Root) RunPing(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	defer r.UpdateHistory()
 	r.ctx.RecordToSession = true
 	if r.ctx.Infinite {
 		r.ctx.Packets = 16
diff --git a/cmd/ping_test.go b/cmd/ping_test.go
index 28c890a..e148ca1 100644
--- a/cmd/ping_test.go
+++ b/cmd/ping_test.go
@@ -33,11 +33,11 @@ func Test_Execute_Ping_Default(t *testing.T) {
 	viewerMock.EXPECT().Output(measurementID1, expectedOpts).Times(1).Return(nil)
 
 	timeMock := mocks.NewMockTime(ctrl)
-	timeMock.EXPECT().Now().Return(defaultCurrentTime)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
 
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(nil, w, w)
-	ctx := createDefaultContext()
+	ctx := createDefaultContext("ping")
 	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 
 	os.Args = []string{"globalping", "ping", "jsdelivr.com"}
@@ -52,8 +52,17 @@ func Test_Execute_Ping_Default(t *testing.T) {
 
 	b, err := os.ReadFile(getMeasurementsPath())
 	assert.NoError(t, err)
-	expectedHistory := []byte(measurementID1 + "\n")
-	assert.Equal(t, expectedHistory, b)
+	expectedHistory := measurementID1 + "\n"
+	assert.Equal(t, expectedHistory, string(b))
+
+	b, err = os.ReadFile(getHistoryPath())
+	assert.NoError(t, err)
+	expectedHistory = createDefaultExpectedHistoryLogItem(
+		"1",
+		measurementID1,
+		"ping jsdelivr.com",
+	)
+	assert.Equal(t, expectedHistory, string(b))
 }
 
 func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
@@ -76,11 +85,11 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	viewerMock.EXPECT().Output(measurementID3, expectedOpts).Times(3).Return(nil).After(c2)
 
 	timeMock := mocks.NewMockTime(ctrl)
-	timeMock.EXPECT().Now().Times(totalCalls).Return(defaultCurrentTime)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
 
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(nil, w, w)
-	ctx := createDefaultContext()
+	ctx := createDefaultContext("ping")
 	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "Berlin,New York "}
 	err := root.Cmd.ExecuteContext(context.TODO())
@@ -90,6 +99,7 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	expectedCtx.From = "Berlin,New York"
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: measurementID1}}
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@-1"}
@@ -97,9 +107,10 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedCtx.From = "@-1"
-	expectedCtx.MeasurementsCreated = 2
+	expectedCtx.IsLocationFromSession = true
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: measurementID1}}
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "last"}
@@ -107,9 +118,9 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedCtx.From = "last"
-	expectedCtx.MeasurementsCreated = 3
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: measurementID1}}
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "previous"}
@@ -117,9 +128,9 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedCtx.From = "previous"
-	expectedCtx.MeasurementsCreated = 4
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: "world"}}
 	expectedResponse.ID = measurementID2
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
@@ -129,9 +140,10 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 
 	expectedCtx.From = "world"
 	expectedCtx.History.Slice[0].Id = measurementID2
-	expectedCtx.MeasurementsCreated = 5
+	expectedCtx.IsLocationFromSession = false
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: measurementID1}}
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@1"}
@@ -139,9 +151,10 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedCtx.From = "@1"
-	expectedCtx.MeasurementsCreated = 6
+	expectedCtx.IsLocationFromSession = true
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: measurementID1}}
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "first"}
@@ -149,9 +162,9 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedCtx.From = "first"
-	expectedCtx.MeasurementsCreated = 7
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: "world"}}
 	expectedResponse.ID = measurementID3
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
@@ -161,9 +174,10 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 
 	expectedCtx.From = "world"
 	expectedCtx.History.Slice[0].Id = measurementID3
-	expectedCtx.MeasurementsCreated = 8
+	expectedCtx.IsLocationFromSession = false
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: measurementID2}}
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@2"}
@@ -172,9 +186,10 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 
 	expectedCtx.From = "@2"
 	expectedCtx.RecordToSession = false
-	expectedCtx.MeasurementsCreated = 9
+	expectedCtx.IsLocationFromSession = true
 	assert.Equal(t, expectedCtx, ctx)
 
+	ctx = createDefaultContext("ping")
 	expectedOpts.Locations = []globalping.Locations{{Magic: measurementID1}}
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@-3"}
@@ -182,7 +197,6 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedCtx.From = "@-3"
-	expectedCtx.MeasurementsCreated = 10
 	assert.Equal(t, expectedCtx, ctx)
 
 	assert.Equal(t, "", w.String())
@@ -192,59 +206,63 @@ func Test_Execute_Ping_Locations_And_Session(t *testing.T) {
 	expectedHistory := []byte(measurementID1 + "\n" + measurementID2 + "\n" + measurementID3 + "\n")
 	assert.Equal(t, expectedHistory, b)
 
+	ctx = createDefaultContext("ping")
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@-4"}
 	err = root.Cmd.ExecuteContext(context.TODO())
 	assert.Error(t, err, ErrIndexOutOfRange)
 
 	expectedCtx.From = "@-4"
+	expectedCtx.IsLocationFromSession = false
 	expectedCtx.RecordToSession = true
+	expectedCtx.MeasurementsCreated = 0
+	expectedCtx.History = view.NewHistoryBuffer(1)
 	assert.Equal(t, expectedCtx, ctx)
 	assert.Equal(t, "Error: index out of range\n", w.String())
 
 	sessionCleanup()
 
 	w.Reset()
+	ctx = createDefaultContext("ping")
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@1"}
 	err = root.Cmd.ExecuteContext(context.TODO())
-	assert.Error(t, err, ErrorNoPreviousMeasurements)
+	assert.Error(t, err, ErrNoPreviousMeasurements)
 
 	expectedCtx.From = "@1"
-	expectedCtx.RecordToSession = true
 	assert.Equal(t, expectedCtx, ctx)
 	assert.Equal(t, "Error: no previous measurements found\n", w.String())
 
 	w.Reset()
+	ctx = createDefaultContext("ping")
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@0"}
 	err = root.Cmd.ExecuteContext(context.TODO())
 	assert.Error(t, err, ErrInvalidIndex)
 
 	expectedCtx.From = "@0"
-	expectedCtx.RecordToSession = true
 	assert.Equal(t, expectedCtx, ctx)
 	assert.Equal(t, "Error: invalid index\n", w.String())
 
 	w.Reset()
+	ctx = createDefaultContext("ping")
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@x"}
 	err = root.Cmd.ExecuteContext(context.TODO())
 	assert.Error(t, err, ErrInvalidIndex)
 
 	expectedCtx.From = "@x"
-	expectedCtx.RecordToSession = true
 	assert.Equal(t, expectedCtx, ctx)
 	assert.Equal(t, "Error: invalid index\n", w.String())
 
 	w.Reset()
+	ctx = createDefaultContext("ping")
 	root = NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "from", "@"}
 	err = root.Cmd.ExecuteContext(context.TODO())
 	assert.Error(t, err, ErrInvalidIndex)
 
 	expectedCtx.From = "@"
-	expectedCtx.RecordToSession = true
 	assert.Equal(t, expectedCtx, ctx)
 	assert.Equal(t, "Error: invalid index\n", w.String())
 }
@@ -322,6 +340,8 @@ func Test_Execute_Ping_Infinite(t *testing.T) {
 	printer := view.NewPrinter(nil, w, w)
 	ctx := &view.Context{
 		History: view.NewHistoryBuffer(10),
+		From:    "world",
+		Limit:   1,
 	}
 	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "--infinite", "from", "Berlin"}
@@ -390,8 +410,17 @@ func Test_Execute_Ping_Infinite(t *testing.T) {
 
 	b, err := os.ReadFile(getMeasurementsPath())
 	assert.NoError(t, err)
-	expectedHistory := []byte(measurementID1 + "\n")
-	assert.Equal(t, expectedHistory, b)
+	expectedHistory := measurementID1 + "\n"
+	assert.Equal(t, expectedHistory, string(b))
+
+	b, err = os.ReadFile(getHistoryPath())
+	assert.NoError(t, err)
+	expectedHistory = createDefaultExpectedHistoryLogItem(
+		"1",
+		measurementID1+"+"+measurementID2+"+"+measurementID3+"+"+measurementID4,
+		"ping jsdelivr.com --infinite from Berlin",
+	)
+	assert.Equal(t, expectedHistory, string(b))
 }
 
 func Test_Execute_Ping_Infinite_Output_Error(t *testing.T) {
@@ -416,11 +445,11 @@ func Test_Execute_Ping_Infinite_Output_Error(t *testing.T) {
 	viewerMock.EXPECT().OutputSummary().Times(0)
 
 	timeMock := mocks.NewMockTime(ctrl)
-	timeMock.EXPECT().Now().Return(defaultCurrentTime)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
 
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(nil, w, w)
-	ctx := createDefaultContext()
+	ctx := createDefaultContext("ping")
 	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "ping", "jsdelivr.com", "--infinite", "from", "Berlin"}
 	err := root.Cmd.ExecuteContext(context.TODO())
@@ -436,6 +465,15 @@ func Test_Execute_Ping_Infinite_Output_Error(t *testing.T) {
 
 	b, err := os.ReadFile(getMeasurementsPath())
 	assert.NoError(t, err)
-	expectedHistory := []byte(measurementID1 + "\n")
-	assert.Equal(t, expectedHistory, b)
+	expectedHistory := measurementID1 + "\n"
+	assert.Equal(t, expectedHistory, string(b))
+
+	b, err = os.ReadFile(getHistoryPath())
+	assert.NoError(t, err)
+	expectedHistory = createDefaultExpectedHistoryLogItem(
+		"1",
+		measurementID1,
+		"ping jsdelivr.com --infinite from Berlin",
+	)
+	assert.Equal(t, expectedHistory, string(b))
 }
diff --git a/cmd/root.go b/cmd/root.go
index 78aa1e8..7eccdfb 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -31,6 +31,8 @@ func Execute() {
 	ctx := &view.Context{
 		APIMinInterval: globalping.API_MIN_INTERVAL,
 		History:        view.NewHistoryBuffer(10),
+		From:           "world",
+		Limit:          1,
 	}
 	globalpingClient := globalping.NewClient(globalping.API_URL)
 	globalpingProbe := probe.NewProbe()
@@ -73,17 +75,16 @@ The CLI tool allows you to interact with the API in a simple and human-friendly
 
 	root.Cmd.SetOut(printer.OutWriter)
 	root.Cmd.SetErr(printer.ErrWriter)
-
 	// Global flags
 	flags := root.Cmd.PersistentFlags()
-	flags.StringVarP(&ctx.From, "from", "F", "world", `Comma-separated list of location values to match against or a measurement ID
+	flags.StringVarP(&ctx.From, "from", "F", ctx.From, `Comma-separated list of location values to match against or a measurement ID
 	For example, the partial or full name of a continent, region (e.g eastern europe), country, US state, city or network
 	Or use [@1 | first, @2 ... @-2, @-1 | last | previous] to run with the probes from previous measurements.`)
-	flags.IntVarP(&ctx.Limit, "limit", "L", 1, "Limit the number of probes to use")
-	flags.BoolVarP(&ctx.ToJSON, "json", "J", false, "Output results in JSON format (default false)")
-	flags.BoolVarP(&ctx.CIMode, "ci", "C", false, "Disable realtime terminal updates and color suitable for CI and scripting (default false)")
-	flags.BoolVar(&ctx.ToLatency, "latency", false, "Output only the stats of a measurement (default false). Only applies to the dns, http and ping commands")
-	flags.BoolVar(&ctx.Share, "share", false, "Prints a link at the end the results, allowing to vizualize the results online (default false)")
+	flags.IntVarP(&ctx.Limit, "limit", "L", ctx.Limit, "Limit the number of probes to use")
+	flags.BoolVarP(&ctx.ToJSON, "json", "J", ctx.ToJSON, "Output results in JSON format (default false)")
+	flags.BoolVarP(&ctx.CIMode, "ci", "C", ctx.CIMode, "Disable realtime terminal updates and color suitable for CI and scripting (default false)")
+	flags.BoolVar(&ctx.ToLatency, "latency", ctx.ToLatency, "Output only the stats of a measurement (default false). Only applies to the dns, http and ping commands")
+	flags.BoolVar(&ctx.Share, "share", ctx.Share, "Prints a link at the end the results, allowing to vizualize the results online (default false)")
 
 	root.Cmd.AddGroup(&cobra.Group{ID: "Measurements", Title: "Measurement Commands:"})
 
@@ -94,6 +95,7 @@ The CLI tool allows you to interact with the API in a simple and human-friendly
 	root.initTraceroute()
 	root.initInstallProbe()
 	root.initVersion()
+	root.initHistory()
 
 	return root
 }
diff --git a/cmd/traceroute.go b/cmd/traceroute.go
index c770791..4cf61f5 100644
--- a/cmd/traceroute.go
+++ b/cmd/traceroute.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/jsdelivr/globalping-cli/globalping"
+	"github.com/jsdelivr/globalping-cli/view"
 	"github.com/spf13/cobra"
 )
 
@@ -46,8 +47,8 @@ Examples:
 
 	// traceroute specific flags
 	flags := tracerouteCmd.Flags()
-	flags.StringVar(&r.ctx.Protocol, "protocol", "", "Specifies the protocol used for tracerouting (ICMP, TCP or UDP) (default \"icmp\")")
-	flags.IntVar(&r.ctx.Port, "port", 0, "Specifies the port to use for the traceroute. Only applicable for TCP protocol (default 80)")
+	flags.StringVar(&r.ctx.Protocol, "protocol", r.ctx.Protocol, "Specifies the protocol used for tracerouting (ICMP, TCP or UDP) (default \"icmp\")")
+	flags.IntVar(&r.ctx.Port, "port", r.ctx.Port, "Specifies the port to use for the traceroute. Only applicable for TCP protocol (default 80)")
 
 	r.Cmd.AddCommand(tracerouteCmd)
 }
@@ -62,6 +63,7 @@ func (r *Root) RunTraceroute(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("the latency flag is not supported by the traceroute command")
 	}
 
+	defer r.UpdateHistory()
 	r.ctx.RecordToSession = true
 
 	opts := &globalping.MeasurementCreate{
@@ -89,7 +91,12 @@ func (r *Root) RunTraceroute(cmd *cobra.Command, args []string) error {
 	}
 
 	r.ctx.MeasurementsCreated++
-
+	hm := &view.HistoryItem{
+		Id:        res.ID,
+		Status:    globalping.StatusInProgress,
+		StartedAt: r.time.Now(),
+	}
+	r.ctx.History.Push(hm)
 	if r.ctx.RecordToSession {
 		r.ctx.RecordToSession = false
 		err := saveIdToSession(res.ID)
diff --git a/cmd/traceroute_test.go b/cmd/traceroute_test.go
index 5a22b2f..40feef5 100644
--- a/cmd/traceroute_test.go
+++ b/cmd/traceroute_test.go
@@ -31,10 +31,13 @@ func Test_Execute_Traceroute_Default(t *testing.T) {
 	viewerMock := mocks.NewMockViewer(ctrl)
 	viewerMock.EXPECT().Output(measurementID1, expectedOpts).Times(1).Return(nil)
 
+	timeMock := mocks.NewMockTime(ctrl)
+	timeMock.EXPECT().Now().Return(defaultCurrentTime).AnyTimes()
+
 	w := new(bytes.Buffer)
 	printer := view.NewPrinter(nil, w, w)
-	ctx := createDefaultContext()
-	root := NewRoot(printer, ctx, viewerMock, nil, gbMock, nil)
+	ctx := createDefaultContext("traceroute")
+	root := NewRoot(printer, ctx, viewerMock, timeMock, gbMock, nil)
 	os.Args = []string{"globalping", "traceroute", "jsdelivr.com",
 		"from", "Berlin",
 		"--limit", "2",
@@ -54,6 +57,15 @@ func Test_Execute_Traceroute_Default(t *testing.T) {
 
 	b, err := os.ReadFile(getMeasurementsPath())
 	assert.NoError(t, err)
-	expectedHistory := []byte(measurementID1 + "\n")
-	assert.Equal(t, expectedHistory, b)
+	expectedHistory := measurementID1 + "\n"
+	assert.Equal(t, expectedHistory, string(b))
+
+	b, err = os.ReadFile(getHistoryPath())
+	assert.NoError(t, err)
+	expectedHistory = createDefaultExpectedHistoryLogItem(
+		"1",
+		measurementID1,
+		"traceroute jsdelivr.com from Berlin --limit 2 --protocol tcp --port 99",
+	)
+	assert.Equal(t, expectedHistory, string(b))
 }
diff --git a/cmd/utils_test.go b/cmd/utils_test.go
index bd08c9f..e8089ac 100644
--- a/cmd/utils_test.go
+++ b/cmd/utils_test.go
@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"errors"
+	"fmt"
 	"io/fs"
 	"os"
 	"time"
@@ -88,10 +89,13 @@ func createDefaultMeasurement_MultipleProbes(cmd string, status globalping.Measu
 	}
 }
 
-func createDefaultContext() *view.Context {
-	return &view.Context{
+func createDefaultContext(_ string) *view.Context {
+	ctx := &view.Context{
 		History: view.NewHistoryBuffer(1),
+		From:    "world",
+		Limit:   1,
 	}
+	return ctx
 }
 
 func createDefaultExpectedContext(cmd string) *view.Context {
@@ -104,12 +108,24 @@ func createDefaultExpectedContext(cmd string) *view.Context {
 		History:             view.NewHistoryBuffer(1),
 		MeasurementsCreated: 1,
 	}
-	if cmd == "ping" {
-		ctx.History.Push(&view.HistoryItem{
-			Id:        measurementID1,
-			Status:    globalping.StatusInProgress,
-			StartedAt: defaultCurrentTime,
-		})
-	}
+	ctx.History.Push(&view.HistoryItem{
+		Id:        measurementID1,
+		Status:    globalping.StatusInProgress,
+		StartedAt: defaultCurrentTime,
+	})
 	return ctx
 }
+
+func createDefaultExpectedHistoryLogItem(index, measurements string, cmd string) string {
+	return fmt.Sprintf("%s|%s|%d|%s|%s\n",
+		HistoryItemVersion1,
+		index,
+		defaultCurrentTime.Unix(),
+		measurements,
+		cmd,
+	)
+}
+
+func createDefaultExpectedHistoryItem(index string, time string, cmd string, measurements string) string {
+	return fmt.Sprintf("%s | %s | %s\n> https://www.jsdelivr.com/globalping?measurement=%s\n", index, time, cmd, measurements)
+}
diff --git a/view/context.go b/view/context.go
index cd33fb8..bc7000b 100644
--- a/view/context.go
+++ b/view/context.go
@@ -29,9 +29,13 @@ type Context struct {
 	Full      bool // Full output
 	Infinite  bool // Infinite flag
 
+	Head uint // Number of first measurements to show
+	Tail uint // Number of last measurements to show
+
 	APIMinInterval time.Duration // Minimum interval between API calls
 
-	RecordToSession bool // Record measurement to session history
+	IsLocationFromSession bool // Determine whether the previous location is used
+	RecordToSession       bool // Record measurement to session history
 
 	Hostname            string
 	IsHeaderPrinted     bool
diff --git a/view/output.go b/view/output.go
index 0b68274..335d507 100644
--- a/view/output.go
+++ b/view/output.go
@@ -10,6 +10,8 @@ import (
 	"github.com/mattn/go-runewidth"
 )
 
+var ShareURL = "https://www.jsdelivr.com/globalping?measurement="
+
 func (v *viewer) Output(id string, m *globalping.MeasurementCreate) error {
 	// Wait for first result to arrive from a probe before starting display (can be in-progress)
 	data, err := v.globalping.GetMeasurement(id)
@@ -140,7 +142,7 @@ func (v *viewer) getProbeInfo(result *globalping.ProbeMeasurement) string {
 }
 
 func (v *viewer) getShareMessage(id string) string {
-	m := fmt.Sprintf("> View the results online: https://www.jsdelivr.com/globalping?measurement=%s", id)
+	m := fmt.Sprintf("> View the results online: %s%s", ShareURL, id)
 	if v.ctx.CIMode {
 		return m
 	}