Black Lives Matter. Support the Equal Justice Initiative.

Source file src/net/http/pprof/pprof_test.go

Documentation: net/http/pprof

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package pprof
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"internal/profile"
    11  	"io"
    12  	"net/http"
    13  	"net/http/httptest"
    14  	"runtime"
    15  	"runtime/pprof"
    16  	"strings"
    17  	"sync"
    18  	"sync/atomic"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  // TestDescriptions checks that the profile names under runtime/pprof package
    24  // have a key in the description map.
    25  func TestDescriptions(t *testing.T) {
    26  	for _, p := range pprof.Profiles() {
    27  		_, ok := profileDescriptions[p.Name()]
    28  		if ok != true {
    29  			t.Errorf("%s does not exist in profileDescriptions map\n", p.Name())
    30  		}
    31  	}
    32  }
    33  
    34  func TestHandlers(t *testing.T) {
    35  	testCases := []struct {
    36  		path               string
    37  		handler            http.HandlerFunc
    38  		statusCode         int
    39  		contentType        string
    40  		contentDisposition string
    41  		resp               []byte
    42  	}{
    43  		{"/debug/pprof/<script>scripty<script>", Index, http.StatusNotFound, "text/plain; charset=utf-8", "", []byte("Unknown profile\n")},
    44  		{"/debug/pprof/heap", Index, http.StatusOK, "application/octet-stream", `attachment; filename="heap"`, nil},
    45  		{"/debug/pprof/heap?debug=1", Index, http.StatusOK, "text/plain; charset=utf-8", "", nil},
    46  		{"/debug/pprof/cmdline", Cmdline, http.StatusOK, "text/plain; charset=utf-8", "", nil},
    47  		{"/debug/pprof/profile?seconds=1", Profile, http.StatusOK, "application/octet-stream", `attachment; filename="profile"`, nil},
    48  		{"/debug/pprof/symbol", Symbol, http.StatusOK, "text/plain; charset=utf-8", "", nil},
    49  		{"/debug/pprof/trace", Trace, http.StatusOK, "application/octet-stream", `attachment; filename="trace"`, nil},
    50  		{"/debug/pprof/mutex", Index, http.StatusOK, "application/octet-stream", `attachment; filename="mutex"`, nil},
    51  		{"/debug/pprof/block?seconds=1", Index, http.StatusOK, "application/octet-stream", `attachment; filename="block-delta"`, nil},
    52  		{"/debug/pprof/goroutine?seconds=1", Index, http.StatusOK, "application/octet-stream", `attachment; filename="goroutine-delta"`, nil},
    53  		{"/debug/pprof/", Index, http.StatusOK, "text/html; charset=utf-8", "", []byte("Types of profiles available:")},
    54  	}
    55  	for _, tc := range testCases {
    56  		t.Run(tc.path, func(t *testing.T) {
    57  			req := httptest.NewRequest("GET", "http://example.com"+tc.path, nil)
    58  			w := httptest.NewRecorder()
    59  			tc.handler(w, req)
    60  
    61  			resp := w.Result()
    62  			if got, want := resp.StatusCode, tc.statusCode; got != want {
    63  				t.Errorf("status code: got %d; want %d", got, want)
    64  			}
    65  
    66  			body, err := io.ReadAll(resp.Body)
    67  			if err != nil {
    68  				t.Errorf("when reading response body, expected non-nil err; got %v", err)
    69  			}
    70  			if got, want := resp.Header.Get("X-Content-Type-Options"), "nosniff"; got != want {
    71  				t.Errorf("X-Content-Type-Options: got %q; want %q", got, want)
    72  			}
    73  			if got, want := resp.Header.Get("Content-Type"), tc.contentType; got != want {
    74  				t.Errorf("Content-Type: got %q; want %q", got, want)
    75  			}
    76  			if got, want := resp.Header.Get("Content-Disposition"), tc.contentDisposition; got != want {
    77  				t.Errorf("Content-Disposition: got %q; want %q", got, want)
    78  			}
    79  
    80  			if resp.StatusCode == http.StatusOK {
    81  				return
    82  			}
    83  			if got, want := resp.Header.Get("X-Go-Pprof"), "1"; got != want {
    84  				t.Errorf("X-Go-Pprof: got %q; want %q", got, want)
    85  			}
    86  			if !bytes.Equal(body, tc.resp) {
    87  				t.Errorf("response: got %q; want %q", body, tc.resp)
    88  			}
    89  		})
    90  	}
    91  }
    92  
    93  var Sink uint32
    94  
    95  func mutexHog1(mu1, mu2 *sync.Mutex, start time.Time, dt time.Duration) {
    96  	atomic.AddUint32(&Sink, 1)
    97  	for time.Since(start) < dt {
    98  		// When using gccgo the loop of mutex operations is
    99  		// not preemptible. This can cause the loop to block a GC,
   100  		// causing the time limits in TestDeltaContentionz to fail.
   101  		// Since this loop is not very realistic, when using
   102  		// gccgo add preemption points 100 times a second.
   103  		t1 := time.Now()
   104  		for time.Since(start) < dt && time.Since(t1) < 10*time.Millisecond {
   105  			mu1.Lock()
   106  			mu2.Lock()
   107  			mu1.Unlock()
   108  			mu2.Unlock()
   109  		}
   110  		if runtime.Compiler == "gccgo" {
   111  			runtime.Gosched()
   112  		}
   113  	}
   114  }
   115  
   116  // mutexHog2 is almost identical to mutexHog but we keep them separate
   117  // in order to distinguish them with function names in the stack trace.
   118  // We make them slightly different, using Sink, because otherwise
   119  // gccgo -c opt will merge them.
   120  func mutexHog2(mu1, mu2 *sync.Mutex, start time.Time, dt time.Duration) {
   121  	atomic.AddUint32(&Sink, 2)
   122  	for time.Since(start) < dt {
   123  		// See comment in mutexHog.
   124  		t1 := time.Now()
   125  		for time.Since(start) < dt && time.Since(t1) < 10*time.Millisecond {
   126  			mu1.Lock()
   127  			mu2.Lock()
   128  			mu1.Unlock()
   129  			mu2.Unlock()
   130  		}
   131  		if runtime.Compiler == "gccgo" {
   132  			runtime.Gosched()
   133  		}
   134  	}
   135  }
   136  
   137  // mutexHog starts multiple goroutines that runs the given hogger function for the specified duration.
   138  // The hogger function will be given two mutexes to lock & unlock.
   139  func mutexHog(duration time.Duration, hogger func(mu1, mu2 *sync.Mutex, start time.Time, dt time.Duration)) {
   140  	start := time.Now()
   141  	mu1 := new(sync.Mutex)
   142  	mu2 := new(sync.Mutex)
   143  	var wg sync.WaitGroup
   144  	wg.Add(10)
   145  	for i := 0; i < 10; i++ {
   146  		go func() {
   147  			defer wg.Done()
   148  			hogger(mu1, mu2, start, duration)
   149  		}()
   150  	}
   151  	wg.Wait()
   152  }
   153  
   154  func TestDeltaProfile(t *testing.T) {
   155  	rate := runtime.SetMutexProfileFraction(1)
   156  	defer func() {
   157  		runtime.SetMutexProfileFraction(rate)
   158  	}()
   159  
   160  	// mutexHog1 will appear in non-delta mutex profile
   161  	// if the mutex profile works.
   162  	mutexHog(20*time.Millisecond, mutexHog1)
   163  
   164  	// If mutexHog1 does not appear in the mutex profile,
   165  	// skip this test. Mutex profile is likely not working,
   166  	// so is the delta profile.
   167  
   168  	p, err := query("/debug/pprof/mutex")
   169  	if err != nil {
   170  		t.Skipf("mutex profile is unsupported: %v", err)
   171  	}
   172  
   173  	if !seen(p, "mutexHog1") {
   174  		t.Skipf("mutex profile is not working: %v", p)
   175  	}
   176  
   177  	// causes mutexHog2 call stacks to appear in the mutex profile.
   178  	done := make(chan bool)
   179  	go func() {
   180  		for {
   181  			mutexHog(20*time.Millisecond, mutexHog2)
   182  			select {
   183  			case <-done:
   184  				done <- true
   185  				return
   186  			default:
   187  				time.Sleep(10 * time.Millisecond)
   188  			}
   189  		}
   190  	}()
   191  	defer func() { // cleanup the above goroutine.
   192  		done <- true
   193  		<-done // wait for the goroutine to exit.
   194  	}()
   195  
   196  	for _, d := range []int{1, 4, 16, 32} {
   197  		endpoint := fmt.Sprintf("/debug/pprof/mutex?seconds=%d", d)
   198  		p, err := query(endpoint)
   199  		if err != nil {
   200  			t.Fatalf("failed to query %q: %v", endpoint, err)
   201  		}
   202  		if !seen(p, "mutexHog1") && seen(p, "mutexHog2") && p.DurationNanos > 0 {
   203  			break // pass
   204  		}
   205  		if d == 32 {
   206  			t.Errorf("want mutexHog2 but no mutexHog1 in the profile, and non-zero p.DurationNanos, got %v", p)
   207  		}
   208  	}
   209  	p, err = query("/debug/pprof/mutex")
   210  	if err != nil {
   211  		t.Fatalf("failed to query mutex profile: %v", err)
   212  	}
   213  	if !seen(p, "mutexHog1") || !seen(p, "mutexHog2") {
   214  		t.Errorf("want both mutexHog1 and mutexHog2 in the profile, got %v", p)
   215  	}
   216  }
   217  
   218  var srv = httptest.NewServer(nil)
   219  
   220  func query(endpoint string) (*profile.Profile, error) {
   221  	url := srv.URL + endpoint
   222  	r, err := http.Get(url)
   223  	if err != nil {
   224  		return nil, fmt.Errorf("failed to fetch %q: %v", url, err)
   225  	}
   226  	if r.StatusCode != http.StatusOK {
   227  		return nil, fmt.Errorf("failed to fetch %q: %v", url, r.Status)
   228  	}
   229  
   230  	b, err := io.ReadAll(r.Body)
   231  	r.Body.Close()
   232  	if err != nil {
   233  		return nil, fmt.Errorf("failed to read and parse the result from %q: %v", url, err)
   234  	}
   235  	return profile.Parse(bytes.NewBuffer(b))
   236  }
   237  
   238  // seen returns true if the profile includes samples whose stacks include
   239  // the specified function name (fname).
   240  func seen(p *profile.Profile, fname string) bool {
   241  	locIDs := map[*profile.Location]bool{}
   242  	for _, loc := range p.Location {
   243  		for _, l := range loc.Line {
   244  			if strings.Contains(l.Function.Name, fname) {
   245  				locIDs[loc] = true
   246  				break
   247  			}
   248  		}
   249  	}
   250  	for _, sample := range p.Sample {
   251  		for _, loc := range sample.Location {
   252  			if locIDs[loc] {
   253  				return true
   254  			}
   255  		}
   256  	}
   257  	return false
   258  }
   259  

View as plain text