├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── agent_client.go
├── agent_connection.go
├── api.go
├── bf_format
├── bf_writer.go
└── bf_writer_test.go
├── configuration.go
├── configuration_test.go
├── dashboard
├── .gitignore
├── .ncurc.json
├── .npmrc
├── config-overrides.js
├── package-lock.json
├── package.json
├── packaging
│ ├── packager.js
│ └── webpack.config-merge.js
├── public
│ └── index.html
└── src
│ ├── App.css
│ ├── App.js
│ ├── App.test.js
│ ├── Content
│ ├── Error.js
│ ├── ProfileList.js
│ ├── ProfilingStatus.js
│ └── index.js
│ ├── Icon
│ └── BlackfireLogo.js
│ ├── Timeago.js
│ ├── Timeagolib.js
│ ├── index.css
│ ├── index.js
│ ├── redux
│ ├── actions
│ │ └── DashboardActions.js
│ ├── constants
│ │ └── DashboardConstants.js
│ ├── fetcher.js
│ ├── reducers
│ │ ├── DashboardReducer.js
│ │ └── index.js
│ └── stores
│ │ ├── configureStore.dev.js
│ │ ├── configureStore.js
│ │ ├── configureStore.prod.js
│ │ └── importStore.js
│ ├── serviceWorker.js
│ └── setupTests.js
├── docker-compose.yml
├── docker
├── Dockerfile
└── entrypoint_dev.sh
├── fixtures
├── test2_blackfire.ini
└── test_blackfire.ini
├── go.mod
├── go.sum
├── http.go
├── log.go
├── pprof_reader
├── README.md
├── fixtures
│ ├── wt.bf
│ └── wt.pprof.gz
├── internal
│ └── profile
│ │ ├── LICENSE
│ │ ├── encode.go
│ │ ├── filter.go
│ │ ├── legacy_profile.go
│ │ ├── profile.go
│ │ ├── proto.go
│ │ └── prune.go
├── pprof_reader_test.go
├── profile.go
├── profile_test.go
└── test.bf
├── probe.go
├── profile.go
├── signal.go
└── statik
└── statik.go
/.gitignore:
--------------------------------------------------------------------------------
1 | go-probe.log
2 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2019-2023 Platform.sh
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
4 | this software and associated documentation files (the "Software"), to deal in
5 | the Software without restriction, including without limitation the rights to
6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
7 | of the Software, and to permit persons to whom the Software is furnished to do
8 | so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 |
21 |
22 | Code in pprof_reader/internal/profile governed by the Go license, specified in pprof_reader/internal/profile/LICENSE.
23 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | project ?= go-blackfire
2 |
3 | # Project name must be compatible with docker-compose
4 | override project := $(shell echo $(project) | tr -d -c '[a-z0-9]' | cut -c 1-55)
5 |
6 | COMPOSE=docker-compose --project-directory . -f docker-compose.yml --project-name $(project)
7 | RUN_DASHBOARD=$(COMPOSE) run --rm --no-deps go_dashboard
8 | ifdef CI
9 | COMPOSE_BUILD_OPT = --progress=plain
10 | endif
11 |
12 | .DEFAULT_GOAL := help
13 |
14 | ##
15 | #### Dashboard
16 | ##
17 |
18 | dashboard-clean: ## Clean dirs
19 | @$(RUN_DASHBOARD) rm -Rf "build" "dist"
20 | .PHONY: dashboard-clean
21 |
22 | dashboard-build: dashboard/node_modules dashboard-clean ## Build the app
23 | @$(RUN_DASHBOARD) npm run build
24 | @$(RUN_DASHBOARD) npm run merge
25 | @$(RUN_DASHBOARD) node packaging/packager.js
26 | @$(RUN_DASHBOARD) rm -Rf build
27 |
28 | @echo "\n\n\n\nApp has been built in \033[32mdashboard/dist/index.html\033[0m, run \033[32mnpm run serve\033[0m to use it\n\n"
29 | .PHONY: dashboard-build
30 |
31 | dashboard-update-statik: dashboard-build
32 | @go get -u github.com/rakyll/statik
33 | @statik -src=dashboard/dist/
34 |
35 | dashboard-serve-dev: dashboard/node_modules ## Serve the app for development purpose (live reload)
36 | @npm run --prefix=dashboard start
37 | .PHONY: dashboard-serve-dev
38 |
39 | dashboard-serve: dashboard-build ## Build then serve the app
40 | @npm run --prefix=dashboard serve
41 | .PHONY: dashboard-serve
42 |
43 | dashboard/node_modules: dashboard/package-lock.json
44 | @$(RUN_DASHBOARD) npm install
45 |
46 | dashboard-test: dashboard/node_modules
47 | @$(RUN_DASHBOARD) npm run test
48 |
49 | dashboard-eslint: dashboard/node_modules
50 | @$(RUN_DASHBOARD) npm run eslint
51 |
52 | dashboard-build-docker:
53 | @$(COMPOSE) pull --parallel
54 | @$(COMPOSE) build --pull --parallel $(COMPOSE_BUILD_OPT)
55 |
56 | down: ## Stop and remove containers, networks, images, and volumes
57 | @$(COMPOSE) down --remove-orphans
58 | .PHONY: down
59 |
60 | help:
61 | @grep -hE '(^[a-zA-Z_-]+:.*?##.*$$)|(^###)' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[32m%-30s\033[0m %s\n", $$1, $$2}' | sed -e 's/\[32m##/[33m\n/'
62 | .PHONY: help
63 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Blackfire Profiler for Go
2 | =========================
3 |
4 | Welcome to the [Blackfire](https://blackfire.io) profiler SDK for Go!
5 |
6 | To integrate Blackfire into your Go applications, [read the
7 | documentation](https://docs.blackfire.io/go/integrations/sdk).
8 |
--------------------------------------------------------------------------------
/agent_client.go:
--------------------------------------------------------------------------------
1 | package blackfire
2 |
3 | // TODO: AgentTimeout
4 |
5 | import (
6 | "bytes"
7 | "encoding/base64"
8 | "encoding/json"
9 | "fmt"
10 | "io/ioutil"
11 | "net/http"
12 | "net/url"
13 | "os"
14 | "path"
15 | "regexp"
16 | "runtime"
17 | "strconv"
18 | "strings"
19 |
20 | "github.com/blackfireio/go-blackfire/bf_format"
21 | "github.com/blackfireio/go-blackfire/pprof_reader"
22 | "github.com/blackfireio/osinfo"
23 | "github.com/rs/zerolog"
24 | )
25 |
26 | type agentClient struct {
27 | agentNetwork string
28 | agentAddress string
29 | signingEndpoint *url.URL
30 | signingAuth string
31 | serverID string
32 | serverToken string
33 | links []*linksMap
34 | profiles []*Profile
35 | logger *zerolog.Logger
36 | signingResponse *signingResponseData
37 | signingResponseIsConsumed bool
38 | }
39 |
40 | type linksMap map[string]map[string]string
41 |
42 | func NewAgentClient(configuration *Configuration) (*agentClient, error) {
43 | agentNetwork, agentAddress, err := parseNetworkAddressString(configuration.AgentSocket)
44 | if err != nil {
45 | return nil, err
46 | }
47 |
48 | signingEndpoint := configuration.HTTPEndpoint
49 | signingEndpoint.Path = path.Join(signingEndpoint.Path, "/api/v1/signing")
50 |
51 | signingResponse, err := signingResponseFromBFQuery(configuration.BlackfireQuery)
52 | if err != nil {
53 | return nil, err
54 | }
55 |
56 | a := &agentClient{
57 | agentNetwork: agentNetwork,
58 | agentAddress: agentAddress,
59 | signingEndpoint: signingEndpoint,
60 | signingAuth: fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(configuration.ClientID+":"+configuration.ClientToken))),
61 | links: make([]*linksMap, 10),
62 | profiles: make([]*Profile, 10),
63 | logger: configuration.Logger,
64 | serverID: configuration.ServerID,
65 | serverToken: configuration.ServerToken,
66 | signingResponse: signingResponse,
67 | signingResponseIsConsumed: signingResponse == nil,
68 | }
69 | return a, nil
70 | }
71 |
72 | func (c *agentClient) CurrentBlackfireQuery() (string, error) {
73 | if err := c.updateSigningRequest(); err != nil {
74 | return "", err
75 | }
76 | return c.signingResponse.QueryString, nil
77 | }
78 |
79 | func (c *agentClient) LastProfiles() []*Profile {
80 | profiles := []*Profile{}
81 | for _, profile := range c.profiles {
82 | if profile == nil {
83 | continue
84 | }
85 | c.logger.Debug().Msgf("Blackfire: Get profile data for %s", profile.UUID)
86 | if err := profile.load(c.signingAuth); err != nil {
87 | c.logger.Debug().Msgf("Blackfire: Unable to get profile data for %s: %s", profile.UUID, err)
88 | continue
89 | }
90 | profiles = append(profiles, profile)
91 | }
92 | return profiles
93 | }
94 |
95 | func (c *agentClient) ProbeOptions() bf_format.ProbeOptions {
96 | return c.signingResponse.Options
97 | }
98 |
99 | func (c *agentClient) getGoVersion() string {
100 | return fmt.Sprintf("go-%s", runtime.Version()[2:])
101 | }
102 |
103 | func (c *agentClient) getBlackfireProbeHeader(hasBlackfireYaml bool) string {
104 | builder := strings.Builder{}
105 | builder.WriteString(c.getGoVersion())
106 | if hasBlackfireYaml {
107 | builder.WriteString(", blackfire_yml")
108 | }
109 | if c.signingResponse.Options.IsTimespanFlagSet() {
110 | builder.WriteString(", timespan")
111 | }
112 | return builder.String()
113 | }
114 |
115 | func (c *agentClient) loadBlackfireYaml() (data []byte, err error) {
116 | filenames := []string{".blackfire.yml", ".blackfire.yaml"}
117 |
118 | var filename string
119 | for _, filename = range filenames {
120 | if data, err = ioutil.ReadFile(filename); err == nil {
121 | c.logger.Debug().Msgf("Loaded %s", filename)
122 | break
123 | } else if os.IsNotExist(err) {
124 | c.logger.Debug().Msgf("%s does not exist", filename)
125 | } else {
126 | return nil, err
127 | }
128 | }
129 | if os.IsNotExist(err) {
130 | err = nil
131 | }
132 | return
133 | }
134 |
135 | func (c *agentClient) sendBlackfireYaml(conn *agentConnection, contents []byte) (err error) {
136 | if err = conn.WriteStringHeader("Blackfire-Yaml-Size", strconv.Itoa(len(contents))); err != nil {
137 | return
138 | }
139 |
140 | c.logger.Debug().Str("blackfire.yml", string(contents)).Msgf("Send blackfire.yml, size %d", len(contents))
141 | err = conn.WriteRawData(contents)
142 | return
143 | }
144 |
145 | func (c *agentClient) sendProfilePrologue(conn *agentConnection) (err error) {
146 | // https://private.blackfire.io/knowledge-base/protocol/profiler/04-sending.html
147 | bfQuery, err := c.CurrentBlackfireQuery()
148 | if err != nil {
149 | return
150 | }
151 |
152 | var osVersion url.Values
153 | if osVersion, err = getProfileOSHeaderValue(); err != nil {
154 | return
155 | }
156 |
157 | var blackfireYaml []byte
158 | if blackfireYaml, err = c.loadBlackfireYaml(); err != nil {
159 | return
160 | }
161 | hasBlackfireYaml := blackfireYaml != nil
162 |
163 | // These must be done separately from the rest of the headers because they
164 | // either must be sent in a specific order, or use nonstandard encoding.
165 | var orderedHeaders []string
166 | if c.serverID != "" && c.serverToken != "" {
167 | orderedHeaders = append(orderedHeaders, fmt.Sprintf("Blackfire-Auth: %v:%v", c.serverID, c.serverToken))
168 | }
169 | orderedHeaders = append(orderedHeaders, fmt.Sprintf("Blackfire-Query: %s", bfQuery))
170 | orderedHeaders = append(orderedHeaders, fmt.Sprintf("Blackfire-Probe: %s", c.getBlackfireProbeHeader(hasBlackfireYaml)))
171 |
172 | unorderedHeaders := make(map[string]interface{})
173 | unorderedHeaders["os-version"] = osVersion
174 |
175 | // We've now consumed the current Blackfire query, and must fetch a new one next time.
176 | c.signingResponseIsConsumed = true
177 |
178 | // Send the ordered headers first, then wait for the Blackfire-Response,
179 | // then send the unordered headers.
180 | if err = conn.WriteOrderedHeaders(orderedHeaders); err != nil {
181 | return
182 | }
183 |
184 | if hasBlackfireYaml {
185 | if err = conn.WriteEndOfHeaders(); err != nil {
186 | return
187 | }
188 |
189 | var responseName string
190 | var responseValue string
191 | if responseName, responseValue, err = conn.ReadEncodedHeader(); err != nil {
192 | return
193 | }
194 | switch responseName {
195 | case "Blackfire-Response":
196 | var values url.Values
197 | if values, err = url.ParseQuery(responseValue); err != nil {
198 | return
199 | }
200 | if result := values.Get("blackfire_yml"); result == "true" {
201 | if err = c.sendBlackfireYaml(conn, blackfireYaml); err != nil {
202 | return
203 | }
204 | }
205 | case "Blackfire-Error":
206 | return fmt.Errorf(strings.TrimSpace(responseValue))
207 | default:
208 | return fmt.Errorf("Unexpected agent response: %s", responseValue)
209 | }
210 | }
211 |
212 | if err = conn.WriteHeaders(unorderedHeaders); err != nil {
213 | return
214 | }
215 | err = conn.WriteEndOfHeaders()
216 | return
217 | }
218 |
219 | func (c *agentClient) SendProfile(profile *pprof_reader.Profile, title string) (err error) {
220 | var conn *agentConnection
221 | if conn, err = newAgentConnection(c.agentNetwork, c.agentAddress, c.logger); err != nil {
222 | return
223 | }
224 | defer func() {
225 | if err == nil {
226 | c.logger.Debug().Msgf("Profile sent")
227 | err = conn.Close()
228 | } else {
229 | // We want the error that occurred earlier, not an error from close.
230 | conn.Close()
231 | }
232 | }()
233 |
234 | if err = c.sendProfilePrologue(conn); err != nil {
235 | return
236 | }
237 |
238 | var response http.Header
239 | if response, err = conn.ReadResponse(); err != nil {
240 | return err
241 | }
242 | if response.Get("Blackfire-Error") != "" {
243 | return fmt.Errorf("Blackfire-Error: %s", response.Get("Blackfire-Error"))
244 | }
245 |
246 | profileBuffer := new(bytes.Buffer)
247 | if err := bf_format.WriteBFFormat(profile, profileBuffer, c.ProbeOptions(), title); err != nil {
248 | return err
249 | }
250 | encodedProfile := profileBuffer.Bytes()
251 |
252 | c.logger.Debug().Str("contents", string(encodedProfile)).Msg("Blackfire: Send profile")
253 | if err = conn.WriteRawData(encodedProfile); err != nil {
254 | return
255 | }
256 |
257 | return
258 | }
259 |
260 | func (c *agentClient) updateSigningRequest() (err error) {
261 | if !c.signingResponseIsConsumed {
262 | return
263 | }
264 |
265 | var response *http.Response
266 | c.logger.Debug().Msgf("Blackfire: Get authorization from %s", c.signingEndpoint)
267 | request, err := http.NewRequest("POST", c.signingEndpoint.String(), nil)
268 | if err != nil {
269 | return
270 | }
271 | request.Header.Add("Authorization", c.signingAuth)
272 | c.logger.Debug().Msg("Blackfire: Send signing request")
273 | client := http.DefaultClient
274 | response, err = client.Do(request)
275 | if err != nil {
276 | return
277 | }
278 | if response.StatusCode != 201 {
279 | return fmt.Errorf("Signing request to %s failed: %s", c.signingEndpoint, response.Status)
280 | }
281 | var responseData []byte
282 | responseData, err = ioutil.ReadAll(response.Body)
283 | if err != nil {
284 | return
285 | }
286 | c.logger.Debug().Interface("response", string(responseData)).Msg("Blackfire: Receive signing response")
287 | err = json.Unmarshal(responseData, &c.signingResponse)
288 | if err != nil {
289 | return fmt.Errorf("JSON error: %v", err)
290 | }
291 | if c.signingResponse.QueryString == "" {
292 | return fmt.Errorf("Signing response blackfire query was empty")
293 | }
294 | profileURL, ok := c.signingResponse.Links["profile"]
295 | if !ok {
296 | return fmt.Errorf("Signing response blackfire profile URL was empty")
297 | }
298 | c.links = append([]*linksMap{&c.signingResponse.Links}, c.links[:9]...)
299 | c.profiles = append([]*Profile{{
300 | UUID: c.signingResponse.UUID,
301 | URL: c.signingResponse.Links["graph_url"]["href"],
302 | APIURL: profileURL["href"],
303 | }}, c.profiles[:9]...)
304 |
305 | c.signingResponseIsConsumed = false
306 |
307 | return
308 | }
309 |
310 | var nonOptionQueryFields = map[string]bool{
311 | "expires": true,
312 | "userId": true,
313 | "agentIds": true,
314 | "collabToken": true,
315 | "signature": true,
316 | }
317 |
318 | func signingResponseFromBFQuery(query string) (response *signingResponseData, err error) {
319 | if query == "" {
320 | return
321 | }
322 | values, err := url.ParseQuery(query)
323 | if err != nil {
324 | return
325 | }
326 |
327 | firstValue := func(values url.Values, key string) string {
328 | if vArr := values[key]; vArr != nil {
329 | if len(vArr) > 0 {
330 | return vArr[0]
331 | }
332 | }
333 | return ""
334 | }
335 |
336 | expires, err := strconv.ParseUint(firstValue(values, "expires"), 10, 64)
337 | if err != nil {
338 | return
339 | }
340 |
341 | response = newSigningResponseData()
342 | response.Agents = values["agentIds"]
343 | response.CollabToken = firstValue(values, "collabToken")
344 | response.Expires = expires
345 | response.QueryString = query
346 | response.Signature = firstValue(values, "signature")
347 | response.UserID = firstValue(values, "userId")
348 |
349 | for key, arrValues := range values {
350 | if nonOptionQueryFields[key] {
351 | continue
352 | }
353 | if len(arrValues) < 1 {
354 | continue
355 | }
356 | response.Options[key] = arrValues[0]
357 | }
358 |
359 | return
360 | }
361 |
362 | func parseNetworkAddressString(agentSocket string) (network string, address string, err error) {
363 | re := regexp.MustCompile(`^([^:]+)://(.*)`)
364 | matches := re.FindAllStringSubmatch(agentSocket, -1)
365 | if matches == nil {
366 | err = fmt.Errorf("Could not parse agent socket value: [%v]", agentSocket)
367 | return
368 | }
369 | network = matches[0][1]
370 | address = matches[0][2]
371 | return
372 | }
373 |
374 | func getProfileOSHeaderValue() (values url.Values, err error) {
375 | var info *osinfo.OSInfo
376 | info, err = osinfo.GetOSInfo()
377 | if err != nil {
378 | return
379 | }
380 |
381 | values = make(url.Values)
382 | values["family"] = []string{info.Family}
383 | values["arch"] = []string{info.Architecture}
384 | values["id"] = []string{info.ID}
385 | values["version"] = []string{info.Version}
386 | if len(info.Codename) > 0 {
387 | values["codename"] = []string{info.Codename}
388 | }
389 | if len(info.Build) > 0 {
390 | values["build"] = []string{info.Build}
391 | }
392 |
393 | return values, nil
394 | }
395 |
396 | type signingResponseData struct {
397 | UserID string `json:"userId"`
398 | ProfileSlot string `json:"profileSlot"`
399 | CollabToken string `json:"collabToken"`
400 | Agents []string `json:"agents"`
401 | Expires uint64 `json:"expires,string"`
402 | Signature string `json:"signature"`
403 | Options bf_format.ProbeOptions `json:"options"`
404 | Links linksMap `json:"_links"`
405 | UUID string `json:"uuid"`
406 | QueryString string `json:"query_string"`
407 | }
408 |
409 | func newSigningResponseData() *signingResponseData {
410 | s := new(signingResponseData)
411 | s.Options = make(bf_format.ProbeOptions)
412 | return s
413 | }
414 |
--------------------------------------------------------------------------------
/agent_connection.go:
--------------------------------------------------------------------------------
1 | package blackfire
2 |
3 | import (
4 | "bufio"
5 | "fmt"
6 | "io"
7 | "net"
8 | "net/http"
9 | "net/textproto"
10 | "net/url"
11 | "regexp"
12 |
13 | "github.com/rs/zerolog"
14 | )
15 |
16 | var headerRegex *regexp.Regexp = regexp.MustCompile(`^([^:]+):(.*)`)
17 |
18 | type agentConnection struct {
19 | conn net.Conn
20 | reader *bufio.Reader
21 | writer *bufio.Writer
22 | logger *zerolog.Logger
23 | }
24 |
25 | func newAgentConnection(network, address string, logger *zerolog.Logger) (*agentConnection, error) {
26 | c := &agentConnection{
27 | logger: logger,
28 | }
29 | err := c.Init(network, address)
30 | return c, err
31 | }
32 |
33 | func (c *agentConnection) Init(network, address string) (err error) {
34 | if c.conn, err = net.Dial(network, address); err != nil {
35 | return
36 | }
37 |
38 | c.reader = bufio.NewReader(c.conn)
39 | c.writer = bufio.NewWriter(c.conn)
40 | return
41 | }
42 |
43 | func (c *agentConnection) ReadEncodedHeader() (name string, urlEncodedValue string, err error) {
44 | line, err := c.reader.ReadString('\n')
45 | if err != nil {
46 | return
47 | }
48 | if line == "\n" {
49 | return
50 | }
51 | c.logger.Debug().Str("read header", line).Msgf("Recv header")
52 | matches := headerRegex.FindAllStringSubmatch(line, -1)
53 | if matches == nil {
54 | err = fmt.Errorf("Could not parse header: [%s]", line)
55 | return
56 | }
57 | name = matches[0][1]
58 | urlEncodedValue = matches[0][2]
59 | return
60 | }
61 |
62 | func (c *agentConnection) ReadResponse() (http.Header, error) {
63 | tp := textproto.NewReader(c.reader)
64 | mimeHeader, err := tp.ReadMIMEHeader()
65 | if err != nil {
66 | if err == io.EOF {
67 | err = io.ErrUnexpectedEOF
68 | }
69 | return nil, err
70 | }
71 | return http.Header(mimeHeader), nil
72 | }
73 |
74 | func (c *agentConnection) WriteEncodedHeader(name string, urlEncodedValue string) error {
75 | line := fmt.Sprintf("%s: %s\n", name, urlEncodedValue)
76 | c.logger.Debug().Str("write header", line).Msgf("Send header")
77 | _, err := c.writer.WriteString(line)
78 | return err
79 | }
80 |
81 | func (c *agentConnection) WriteStringHeader(name string, value string) error {
82 | return c.WriteEncodedHeader(name, url.QueryEscape(value))
83 | }
84 |
85 | func (c *agentConnection) WriteMapHeader(name string, values url.Values) error {
86 | return c.WriteEncodedHeader(name, values.Encode())
87 | }
88 |
89 | // Write headers in a specific order.
90 | // The headers are assumed to be formatted and URL encoded properly.
91 | func (c *agentConnection) WriteOrderedHeaders(encodedHeaders []string) error {
92 | for _, header := range encodedHeaders {
93 | c.logger.Debug().Str("write header", header).Msgf("Send ordered header")
94 | if _, err := c.writer.WriteString(header); err != nil {
95 | return err
96 | }
97 | if _, err := c.writer.WriteString("\n"); err != nil {
98 | return err
99 | }
100 | }
101 | return nil
102 | }
103 |
104 | func (c *agentConnection) WriteHeaders(nonEncodedHeaders map[string]interface{}) error {
105 | for k, v := range nonEncodedHeaders {
106 | if asString, ok := v.(string); ok {
107 | if err := c.WriteStringHeader(k, asString); err != nil {
108 | return err
109 | }
110 | } else {
111 | if err := c.WriteMapHeader(k, v.(url.Values)); err != nil {
112 | return err
113 | }
114 | }
115 | }
116 | return nil
117 | }
118 |
119 | func (c *agentConnection) WriteEndOfHeaders() (err error) {
120 | c.logger.Debug().Msgf("Send end-of-headers")
121 | if _, err = c.writer.WriteString("\n"); err != nil {
122 | return
123 | }
124 | return c.Flush()
125 | }
126 |
127 | func (c *agentConnection) WriteRawData(data []byte) error {
128 | _, err := c.writer.Write(data)
129 | return err
130 | }
131 |
132 | func (c *agentConnection) Flush() error {
133 | return c.writer.Flush()
134 | }
135 |
136 | func (c *agentConnection) Close() error {
137 | c.Flush()
138 | return c.conn.Close()
139 | }
140 |
--------------------------------------------------------------------------------
/api.go:
--------------------------------------------------------------------------------
1 | package blackfire
2 |
3 | import (
4 | "errors"
5 | "time"
6 | )
7 |
8 | var ProfilerErrorAlreadyProfiling = errors.New("A Blackfire profile is currently in progress. Please wait for it to finish.")
9 |
10 | // Configure explicitely configures the probe. This should be done before any other API calls.
11 | //
12 | // Configuration is initialized in a set order, with later steps overriding
13 | // earlier steps:
14 | //
15 | // * Defaults
16 | // * INI file
17 | // * Explicit configuration in Go code
18 | // * Environment variables
19 | //
20 | // config will be ignored if nil.
21 | func Configure(config *Configuration) {
22 | globalProbe.Configure(config)
23 | }
24 |
25 | // IsProfiling checks if the profiler is running. Only one profiler may run at a time.
26 | func IsProfiling() bool {
27 | return globalProbe.IsProfiling()
28 | }
29 |
30 | // EnableNowFor profiles the current process for the specified duration, then
31 | // connects to the agent and uploads the generated profile.
32 | func EnableNowFor(duration time.Duration) Ender {
33 | globalProbe.EnableNowFor(duration)
34 | return globalProbe.ender
35 | }
36 |
37 | // EnableNow starts profiling. Profiling will continue until you call StopProfiling().
38 | // If you forget to stop profiling, it will automatically stop after the maximum
39 | // allowed duration (DefaultMaxProfileDuration or whatever you set via SetMaxProfileDuration()).
40 | func EnableNow() Ender {
41 | globalProbe.EnableNow()
42 | return globalProbe.ender
43 | }
44 |
45 | // Enable() only profiles when trigerred from an external event (like using blackfire run).
46 | func Enable() Ender {
47 | globalProbe.Enable()
48 | return globalProbe.ender
49 | }
50 |
51 | // Disable stops profiling.
52 | func Disable() {
53 | globalProbe.Disable()
54 | }
55 |
56 | // End ends the current profile, then blocks until the result is uploaded
57 | // to the agent.
58 | func End() {
59 | globalProbe.End()
60 | }
61 |
62 | // EndNoWait stops profiling, then uploads the result to the agent in a separate
63 | // goroutine. You must ensure that the program does not exit before uploading
64 | // is complete. If you can't make such a guarantee, use End() instead.
65 | func EndNoWait() {
66 | globalProbe.EndNoWait()
67 | }
68 |
69 | // GenerateSubProfileQuery generates a Blackfire query
70 | // to attach a subprofile with the current one as a parent
71 | func GenerateSubProfileQuery() (string, error) {
72 | return globalProbe.GenerateSubProfileQuery()
73 | }
74 |
75 | // SetCurrentTitle Sets the title to use for following profiles
76 | func SetCurrentTitle(title string) {
77 | globalProbe.SetCurrentTitle(title)
78 | }
79 |
80 | // globalProbe is the access point for all probe functionality. The API, signal,
81 | // and HTTP interfaces perform all operations by proxying to globalProbe. This
82 | // ensures that mutexes and other guards are respected, and no interface can
83 | // trigger functionality that others can't, or in a way that others can't.
84 | var globalProbe = newProbe()
85 |
--------------------------------------------------------------------------------
/bf_format/bf_writer.go:
--------------------------------------------------------------------------------
1 | package bf_format
2 |
3 | import (
4 | "bufio"
5 | "fmt"
6 | "io"
7 | "net/url"
8 | "os"
9 | "runtime"
10 | "strconv"
11 | "strings"
12 |
13 | "github.com/blackfireio/go-blackfire/pprof_reader"
14 | "github.com/blackfireio/osinfo"
15 | )
16 |
17 | // Write a parsed profile out as a Blackfire profile.
18 | func WriteBFFormat(profile *pprof_reader.Profile, w io.Writer, options ProbeOptions, title string) (err error) {
19 | const headerCostDimensions = "cpu pmu"
20 | const headerProfiledLanguage = "go"
21 | const headerProfilerType = "statistical"
22 |
23 | osInfo, err := osinfo.GetOSInfo()
24 | if err != nil {
25 | return
26 | }
27 |
28 | headers := make(map[string]string)
29 | headers["Cost-Dimensions"] = headerCostDimensions
30 | headers["graph-root-id"] = "go"
31 | headers["probed-os"] = osInfo.Name
32 | headers["profiler-type"] = headerProfilerType
33 | headers["probed-language"] = headerProfiledLanguage
34 | headers["probed-runtime"] = runtime.Version()
35 | headers["probed-cpu-sample-rate"] = strconv.Itoa(profile.CpuSampleRateHz)
36 | headers["probed-features"] = generateProbedFeaturesHeader(options)
37 | headers["Context"] = generateContextHeader()
38 |
39 | if title != "" {
40 | headers["Profile-Title"] = fmt.Sprintf(`{"blackfire-metadata":{"title":"%s"}}`, title)
41 | }
42 |
43 | bufW := bufio.NewWriter(w)
44 | defer func() {
45 | bufErr := bufW.Flush()
46 | if err != nil {
47 | err = bufErr
48 | }
49 | }()
50 |
51 | if _, err = bufW.WriteString("file-format: BlackfireProbe\n"); err != nil {
52 | return
53 | }
54 |
55 | // Begin headers
56 | for k, v := range headers {
57 | if _, err = bufW.WriteString(fmt.Sprintf("%s: %s\n", k, v)); err != nil {
58 | return
59 | }
60 | }
61 |
62 | if options.IsTimespanFlagSet() {
63 | if err = writeTimelineData(profile, bufW); err != nil {
64 | return
65 | }
66 | }
67 |
68 | // End of headers
69 | if _, err = bufW.WriteString("\n"); err != nil {
70 | return
71 | }
72 |
73 | // Profile data
74 | err = writeSamples(profile, bufW)
75 |
76 | return
77 | }
78 |
79 | func generateContextHeaderFromArgs(args []string) string {
80 | s := strings.Builder{}
81 | s.WriteString("script=")
82 | s.WriteString(url.QueryEscape(args[0]))
83 | for i := 0; i < len(args); i++ {
84 | argv := url.QueryEscape(fmt.Sprintf("argv[%d]", i))
85 | value := url.QueryEscape(args[i])
86 | s.WriteString(fmt.Sprintf("&%s=%s", argv, value))
87 | }
88 |
89 | return s.String()
90 | }
91 |
92 | func generateContextHeader() string {
93 | return generateContextHeaderFromArgs(os.Args)
94 | }
95 |
96 | func writeSamples(profile *pprof_reader.Profile, bufW *bufio.Writer) (err error) {
97 | totalCPUTime := uint64(0)
98 | totalMemUsage := uint64(0)
99 |
100 | for _, sample := range profile.Samples {
101 | totalCPUTime += sample.CPUTime
102 |
103 | if len(sample.Stack) == 0 {
104 | continue
105 | }
106 |
107 | // Fake "go" top-of-stack
108 | if _, err = bufW.WriteString(fmt.Sprintf("go==>%s//%d %d %d\n",
109 | sample.Stack[0].Name,
110 | sample.Count, sample.CPUTime, sample.MemUsage)); err != nil {
111 | return
112 | }
113 |
114 | stackMemUsage := uint64(0)
115 | // Skip index 0 because every edge needs a begin and end node
116 | for iStack := len(sample.Stack) - 1; iStack > 0; iStack-- {
117 | f := sample.Stack[iStack]
118 | edgeMemCost := f.DistributedMemoryCost * uint64(sample.Count)
119 | totalMemUsage += edgeMemCost
120 | stackMemUsage += edgeMemCost
121 |
122 | fPrev := sample.Stack[iStack-1]
123 | if _, err = bufW.WriteString(fmt.Sprintf("%s==>%s//%d %d %d\n",
124 | fPrev.Name, f.Name,
125 | sample.Count, sample.CPUTime, stackMemUsage)); err != nil {
126 | return
127 | }
128 | }
129 | }
130 |
131 | if _, err = bufW.WriteString(fmt.Sprintf("==>go//%d %d %d\n", 1, totalCPUTime, totalMemUsage)); err != nil {
132 | return
133 | }
134 |
135 | return
136 | }
137 |
138 | type timelineEntry struct {
139 | Parent *pprof_reader.Function
140 | Function *pprof_reader.Function
141 | CPUStart uint64
142 | CPUEnd uint64
143 | MemStart uint64
144 | MemEnd uint64
145 | }
146 |
147 | func (t *timelineEntry) String() string {
148 | return fmt.Sprintf("%v==>%v", t.Parent, t.Function)
149 | }
150 |
151 | func writeTimelineData(profile *pprof_reader.Profile, bufW *bufio.Writer) (err error) {
152 | tlEntriesByEndTime := make([]*timelineEntry, 0, 10)
153 |
154 | // Insert 2-level fake root so that the timeline visualizer has "go" as the
155 | // top of the stack.
156 | fakeStackTop := []*pprof_reader.Function{
157 | &pprof_reader.Function{
158 | Name: "golang",
159 | ReferenceCount: 1,
160 | },
161 | &pprof_reader.Function{
162 | Name: "go",
163 | ReferenceCount: 1,
164 | },
165 | }
166 |
167 | var alteredSamples []*pprof_reader.Sample
168 | for _, sample := range profile.Samples {
169 | newStack := make([]*pprof_reader.Function, 0, len(sample.Stack)+len(fakeStackTop))
170 | newStack = append(newStack, fakeStackTop...)
171 | newStack = append(newStack, sample.Stack...)
172 | alteredSamples = append(alteredSamples, sample.CloneWithStack(newStack))
173 | }
174 | profile = profile.CloneWithSamples(alteredSamples)
175 |
176 | // Keeps track of the currently "active" functions as we move from stack to stack.
177 | activeTLEntries := make(map[string]*timelineEntry)
178 | // Since these are fake, we need to manually add them to the active list.
179 | for _, f := range fakeStackTop {
180 | activeTLEntries[f.Name] = &timelineEntry{}
181 | }
182 |
183 | prevSample := &pprof_reader.Sample{}
184 | currentCPUTime := uint64(0)
185 | lastMatchStackIndex := 0
186 | for _, nowSample := range profile.Samples {
187 | prevStackEnd := len(prevSample.Stack) - 1
188 | nowStackEnd := len(nowSample.Stack) - 1
189 | shortestStackEnd := prevStackEnd
190 | if nowStackEnd < shortestStackEnd {
191 | shortestStackEnd = nowStackEnd
192 | }
193 |
194 | // Find the last index where the previous and current stack are in the same function.
195 | lastMatchStackIndex = 0
196 | for i := 0; i <= shortestStackEnd; i++ {
197 | if nowSample.Stack[i].Name != prevSample.Stack[i].Name {
198 | break
199 | }
200 | tlEntry := activeTLEntries[nowSample.Stack[i].Name]
201 | tlEntry.CPUEnd += nowSample.CPUTime
202 | lastMatchStackIndex = i
203 | }
204 |
205 | // If the previous stack has entries that the current does not, those
206 | // functions have now ended. Mark them ended in leaf-to-root order.
207 | if lastMatchStackIndex < prevStackEnd {
208 | for i := prevStackEnd; i > lastMatchStackIndex; i-- {
209 | functionName := prevSample.Stack[i].Name
210 | tlEntry := activeTLEntries[functionName]
211 | activeTLEntries[functionName] = nil
212 | tlEntriesByEndTime = append(tlEntriesByEndTime, tlEntry)
213 | }
214 | }
215 |
216 | // If the current stack has entries that the previous does not, they
217 | // are newly invoked functions, so mark them started.
218 | if lastMatchStackIndex < nowStackEnd {
219 | for i := lastMatchStackIndex + 1; i <= nowStackEnd; i++ {
220 | tlEntry := &timelineEntry{
221 | Parent: nowSample.Stack[i-1],
222 | Function: nowSample.Stack[i],
223 | MemStart: nowSample.MemUsage,
224 | MemEnd: nowSample.MemUsage,
225 | CPUStart: currentCPUTime,
226 | CPUEnd: currentCPUTime + nowSample.CPUTime,
227 | }
228 | activeTLEntries[tlEntry.Function.Name] = tlEntry
229 | }
230 | }
231 |
232 | currentCPUTime += nowSample.CPUTime
233 | prevSample = nowSample
234 | }
235 |
236 | // Artificially end all still-active functions because the profile is ended.
237 | // Like before, this must be done in leaf-to-root order.
238 | for i := lastMatchStackIndex; i >= 1; i-- {
239 | tlEntry := activeTLEntries[prevSample.Stack[i].Name]
240 | tlEntriesByEndTime = append(tlEntriesByEndTime, tlEntry)
241 | }
242 |
243 | for i, entry := range tlEntriesByEndTime {
244 | name := entry.Function.Name
245 |
246 | if entry.Parent != nil {
247 | pName := entry.Parent.Name
248 |
249 | if _, err = bufW.WriteString(fmt.Sprintf("Threshold-%d-start: %s==>%s//%d %d\n", i, pName, name, entry.CPUStart, entry.MemStart)); err != nil {
250 | return
251 | }
252 | if _, err = bufW.WriteString(fmt.Sprintf("Threshold-%d-end: %s==>%s//%d %d\n", i, pName, name, entry.CPUEnd, entry.MemEnd)); err != nil {
253 | return
254 | }
255 | } else {
256 | if _, err = bufW.WriteString(fmt.Sprintf("Threshold-%d-start: %s//%d %d\n", i, name, entry.CPUStart, entry.MemStart)); err != nil {
257 | return
258 | }
259 | if _, err = bufW.WriteString(fmt.Sprintf("Threshold-%d-end: %s//%d %d\n", i, name, entry.CPUEnd, entry.MemEnd)); err != nil {
260 | return
261 | }
262 | }
263 | }
264 |
265 | return
266 | }
267 |
268 | var allowedProbedFeatures = map[string]bool{
269 | "signature": true,
270 | "expires": true,
271 | "agentIds": true,
272 | "auto_enable": true,
273 | "aggreg_samples": true,
274 | "flag_cpu": true,
275 | "flag_memory": true,
276 | "flag_no_builtins": true,
277 | "flag_nw": true,
278 | "flag_fn_args": true,
279 | "flag_timespan": true,
280 | "flag_pdo": true,
281 | "flag_sessions": true,
282 | "flag_yml": true,
283 | "flag_composer": true,
284 | "config_yml": true,
285 | "profile_title": true,
286 | "sub_profile": true,
287 | "timespan_threshold": true,
288 | "no_pruning": true,
289 | "no_signature_forwarding": true,
290 | "no_anon": true,
291 | }
292 |
293 | func isAllowedProbedFeature(name string) bool {
294 | _, ok := allowedProbedFeatures[name]
295 | return ok
296 | }
297 |
298 | func generateProbedFeaturesHeader(options ProbeOptions) string {
299 | var builder strings.Builder
300 | firstItem := true
301 | for k, v := range options {
302 | if !isAllowedProbedFeature(k) {
303 | continue
304 | }
305 | if !firstItem {
306 | builder.WriteString("&")
307 | }
308 | builder.WriteString(fmt.Sprintf("%v=%v", k, v))
309 | firstItem = false
310 | }
311 | return builder.String()
312 | }
313 |
314 | type ProbeOptions map[string]interface{}
315 |
316 | func (p ProbeOptions) getOption(name string) interface{} {
317 | if value, ok := p[name]; ok {
318 | return value
319 | }
320 | return nil
321 | }
322 |
323 | func (p ProbeOptions) IsTimespanFlagSet() bool {
324 | // Super ugly, but the actual type can be anything the json decoder chooses,
325 | // so we must go by its string representation.
326 | return fmt.Sprintf("%v", p.getOption("flag_timespan")) == "1"
327 | }
328 |
--------------------------------------------------------------------------------
/bf_format/bf_writer_test.go:
--------------------------------------------------------------------------------
1 | package bf_format
2 |
3 | import (
4 | "bytes"
5 | "runtime"
6 | "strconv"
7 | "strings"
8 | "testing"
9 |
10 | "github.com/blackfireio/go-blackfire/pprof_reader"
11 | "github.com/blackfireio/osinfo"
12 | "github.com/stretchr/testify/assert"
13 | )
14 |
15 | type Headers map[string]interface{}
16 |
17 | func TestGenerateContextStringFromSlice(t *testing.T) {
18 | args := []string{"./test", "--bar"}
19 | expected := "script=.%2Ftest&argv%5B0%5D=.%2Ftest&argv%5B1%5D=--bar"
20 | got := generateContextHeaderFromArgs(args)
21 | if expected != got {
22 | t.Errorf("generateContextStringFromSlice: Expected %v. Got %v", expected, got)
23 | }
24 | }
25 |
26 | func TestProbeOptionsAccessors(t *testing.T) {
27 | assert := assert.New(t)
28 | options := make(ProbeOptions)
29 |
30 | assert.Nil(options.getOption("unknown"))
31 |
32 | expectedValue := "This is a string"
33 | options["my-key"] = expectedValue
34 | assert.Equal(expectedValue, options.getOption("my-key"))
35 |
36 | assert.False(options.IsTimespanFlagSet())
37 |
38 | options["flag_timespan"] = 0
39 | assert.False(options.IsTimespanFlagSet())
40 |
41 | options["flag_timespan"] = 1
42 | assert.True(options.IsTimespanFlagSet())
43 | }
44 |
45 | func TestWriteBFFormat(t *testing.T) {
46 | validProfile := pprof_reader.NewProfile()
47 | validProfile.CpuSampleRateHz = 42
48 | validProfile.Samples = append(validProfile.Samples, &pprof_reader.Sample{
49 | Count: 1,
50 | CPUTime: 100,
51 | })
52 |
53 | cases := []struct {
54 | name string
55 | profile *pprof_reader.Profile
56 | options ProbeOptions
57 | title string
58 | expectedHeaders Headers
59 | expectedBody string
60 | }{
61 | {
62 | "Empty case",
63 | pprof_reader.NewProfile(),
64 | make(ProbeOptions),
65 | "",
66 | Headers{},
67 | "==>go//1 0 0\n",
68 | },
69 | {
70 | "With Title",
71 | pprof_reader.NewProfile(),
72 | make(ProbeOptions),
73 | "This is my Title",
74 | Headers{
75 | "Profile-Title": `{"blackfire-metadata":{"title":"This is my Title"}}`,
76 | },
77 | "==>go//1 0 0\n",
78 | },
79 | {
80 | "With Features",
81 | pprof_reader.NewProfile(),
82 | ProbeOptions{
83 | "signature": "abcd",
84 | "auto_enable": "true",
85 | "no_pruning": "false",
86 | },
87 | "",
88 | Headers{},
89 | "==>go//1 0 0\n",
90 | },
91 | {
92 | "With invalid features",
93 | pprof_reader.NewProfile(),
94 | ProbeOptions{
95 | "unknown": "true",
96 | "ignored": "true",
97 | },
98 | "",
99 | Headers{"probed-features": ProbeOptions{}},
100 | "==>go//1 0 0\n",
101 | },
102 | {
103 | "With valid profile",
104 | validProfile,
105 | ProbeOptions{},
106 | "",
107 | Headers{},
108 | "==>go//1 100 0\n",
109 | },
110 | {
111 | "All mixed",
112 | validProfile,
113 | ProbeOptions{
114 | "signature": "abcd",
115 | "unknown": "true",
116 | "no_pruning": "false",
117 | "ignored": "true",
118 | },
119 | "My-title",
120 | Headers{
121 | "probed-features": ProbeOptions{
122 | "signature": "abcd",
123 | "no_pruning": "false",
124 | },
125 | "Profile-Title": `{"blackfire-metadata":{"title":"My-title"}}`,
126 | },
127 | "==>go//1 100 0\n",
128 | },
129 | }
130 |
131 | for _, c := range cases {
132 | t.Run(c.name, func(t *testing.T) {
133 | fullHeaders := defaultHeaders(c.profile, c.options, c.expectedHeaders)
134 | _TestWriteBFFormat(t, c.profile, c.options, c.title, fullHeaders, c.expectedBody)
135 | })
136 | }
137 | }
138 |
139 | func _TestWriteBFFormat(t *testing.T, profile *pprof_reader.Profile, options ProbeOptions, title string, expectedHeaders Headers, expectedBody string) {
140 | assert := assert.New(t)
141 | var buffer bytes.Buffer
142 |
143 | assert.Nil(WriteBFFormat(profile, &buffer, options, title))
144 | // file-format must always be first
145 | assert.Equal("file-format: BlackfireProbe\n", buffer.String()[:28])
146 |
147 | parts := strings.Split(buffer.String(), "\n\n")
148 | assert.Equal(2, len(parts))
149 |
150 | assert.Equal(expectedHeaders, headersToMap(parts[0]))
151 | assert.Equal(expectedBody, parts[1])
152 | }
153 |
154 | // headersToMap Order of headers in string is not predictable.
155 | // Then we convert them back to a map since assert library can
156 | // handle their comparison.
157 | func headersToMap(headers string) (m Headers) {
158 | m = Headers{}
159 | for _, line := range strings.Split(headers, "\n") {
160 | parts := strings.Split(line, ": ")
161 | m[parts[0]] = parts[1]
162 | }
163 | // probed-features are also built upon a map
164 | if features, found := m["probed-features"]; found {
165 | options := ProbeOptions{}
166 | if len(features.(string)) > 0 {
167 | for _, feature := range strings.Split(features.(string), "&") {
168 | parts := strings.Split(feature, "=")
169 | options[parts[0]] = parts[1]
170 | }
171 | }
172 | m["probed-features"] = options
173 | }
174 | return
175 | }
176 |
177 | func defaultHeaders(profile *pprof_reader.Profile, options ProbeOptions, override Headers) (headers Headers) {
178 | osInfo, err := osinfo.GetOSInfo()
179 | if err != nil {
180 | panic("Cannot retrieve osInfo")
181 | }
182 |
183 | headers = Headers{
184 | "file-format": "BlackfireProbe",
185 | "Cost-Dimensions": "cpu pmu",
186 | "graph-root-id": "go",
187 | "probed-os": osInfo.Name,
188 | "profiler-type": "statistical",
189 | "probed-language": "go",
190 | "probed-runtime": runtime.Version(),
191 | "probed-cpu-sample-rate": strconv.Itoa(profile.CpuSampleRateHz),
192 | "probed-features": options,
193 | "Context": generateContextHeader(),
194 | }
195 | for k, v := range override {
196 | headers[k] = v
197 | }
198 | return
199 | }
200 |
--------------------------------------------------------------------------------
/configuration.go:
--------------------------------------------------------------------------------
1 | package blackfire
2 |
3 | import (
4 | "errors"
5 | "fmt"
6 | "io/ioutil"
7 | "net/url"
8 | "os"
9 | "path"
10 | "path/filepath"
11 | "regexp"
12 | "runtime"
13 | "strconv"
14 | "sync"
15 | "time"
16 |
17 | "github.com/go-ini/ini"
18 | "github.com/rs/zerolog"
19 | )
20 |
21 | // This must match the value of `hz` in StartCPUProfile in runtime/pprof/pprof.go
22 | // It's always been 100hz since the beginning, so it should be safe.
23 | const golangDefaultCPUSampleRate = 100
24 |
25 | type Configuration struct {
26 | // The configuration path to the Blackfire CLI ini file
27 | // Defaults to ~/.blackfire.ini
28 | ConfigFile string
29 |
30 | // Time before dropping an unresponsive agent connection (default 250ms)
31 | AgentTimeout time.Duration
32 |
33 | // The socket to use when connecting to the Blackfire agent (default depends on OS)
34 | AgentSocket string
35 |
36 | // The Blackfire query string to be sent with any profiles. This is either
37 | // provided by the `blackfire run` command in an ENV variable, or acquired
38 | // via a signing request to Blackfire. You won't need to set this manually.
39 | BlackfireQuery string
40 |
41 | // Client ID to authenticate with the Blackfire API
42 | ClientID string
43 |
44 | // Client token to authenticate with the Blackfire API
45 | ClientToken string
46 |
47 | // Server ID for Blackfire-Auth header
48 | ServerID string
49 |
50 | // Server token for Blackfire-Auth header
51 | ServerToken string
52 |
53 | // The Blackfire API endpoint the profile data will be sent to (default https://blackfire.io)
54 | HTTPEndpoint *url.URL
55 |
56 | // A zerolog Logger (default stderr)
57 | Logger *zerolog.Logger
58 |
59 | // The maximum duration of a profile. A profile operation can never exceed
60 | // this duration (default 10 minutes).
61 | // This guards against runaway profile operations.
62 | MaxProfileDuration time.Duration
63 |
64 | // Default rate at which the CPU samples are taken. Values > 500 will likely
65 | // exceed the abilities of most environments.
66 | // See https://golang.org/src/runtime/pprof/pprof.go#L727
67 | DefaultCPUSampleRateHz int
68 |
69 | // If not empty, dump the original pprof profiles to this directory whenever
70 | // a profile ends.
71 | PProfDumpDir string
72 |
73 | // Disables the profiler unless the BLACKFIRE_QUERY env variable is set.
74 | // When the profiler is disabled, all API calls become no-ops.
75 | onDemandOnly bool
76 |
77 | loader sync.Once
78 | err error
79 | }
80 |
81 | func (c *Configuration) canProfile() bool {
82 | if c.BlackfireQuery == "" && c.onDemandOnly {
83 | return false
84 | }
85 | return true
86 | }
87 |
88 | func (c *Configuration) setEndpoint(endpoint string) error {
89 | u, err := url.Parse(endpoint)
90 | if err != nil {
91 | return err
92 | }
93 | c.HTTPEndpoint = u
94 | return nil
95 | }
96 |
97 | func (c *Configuration) getDefaultIniPath() string {
98 | getIniPath := func(dir string) string {
99 | if dir == "" {
100 | return ""
101 | }
102 | fileName := ".blackfire.ini"
103 | filePath := path.Join(path.Clean(dir), fileName)
104 | _, err := os.Stat(filePath)
105 | c.Logger.Debug().Msgf("Blackfire: Does configuration file exist at %s: %t", filePath, err == nil)
106 | if err != nil {
107 | return ""
108 | }
109 | return filePath
110 | }
111 |
112 | if iniPath := getIniPath(c.readEnvVar("BLACKFIRE_HOME")); iniPath != "" {
113 | return iniPath
114 | }
115 |
116 | if runtime.GOOS == "linux" {
117 | if iniPath := getIniPath(os.Getenv("XDG_CONFIG_HOME")); iniPath != "" {
118 | return iniPath
119 | }
120 | }
121 |
122 | if iniPath := getIniPath(os.Getenv("HOME")); iniPath != "" {
123 | return iniPath
124 | }
125 |
126 | if runtime.GOOS == "windows" {
127 | homedrive := os.Getenv("HOMEDRIVE")
128 | homepath := os.Getenv("HOMEPATH")
129 | if homedrive != "" && homepath != "" {
130 | dir := path.Join(path.Dir(homedrive), homepath)
131 | if iniPath := getIniPath(dir); iniPath != "" {
132 | return iniPath
133 | }
134 | }
135 | }
136 |
137 | return ""
138 | }
139 |
140 | func (c *Configuration) configureFromDefaults() {
141 | if c.AgentSocket == "" {
142 | switch runtime.GOOS {
143 | case "windows":
144 | c.AgentSocket = "tcp://127.0.0.1:8307"
145 | case "darwin":
146 | if runtime.GOARCH == "arm64" {
147 | c.AgentSocket = "unix:///opt/homebrew/var/run/blackfire-agent.sock"
148 | } else {
149 | c.AgentSocket = "unix:///usr/local/var/run/blackfire-agent.sock"
150 | }
151 | default:
152 | c.AgentSocket = "unix:///var/run/blackfire/agent.sock"
153 | }
154 | }
155 |
156 | if c.HTTPEndpoint == nil {
157 | c.setEndpoint("https://blackfire.io")
158 | }
159 | if c.AgentTimeout < 1 {
160 | c.AgentTimeout = time.Millisecond * 250
161 | }
162 | if c.MaxProfileDuration < 1 {
163 | c.MaxProfileDuration = time.Minute * 10
164 | }
165 | if c.DefaultCPUSampleRateHz == 0 {
166 | c.DefaultCPUSampleRateHz = golangDefaultCPUSampleRate
167 | }
168 | }
169 |
170 | func (c *Configuration) configureFromIniFile() {
171 | path := c.ConfigFile
172 | if path == "" {
173 | if path = c.getDefaultIniPath(); path == "" {
174 | return
175 | }
176 | }
177 |
178 | iniConfig, err := ini.Load(path)
179 | if err != nil {
180 | c.Logger.Error().Msgf("Blackfire: Could not load Blackfire config file %s: %v", path, err)
181 | return
182 | }
183 |
184 | section := iniConfig.Section("blackfire")
185 | if section.HasKey("client-id") && c.ClientID == "" {
186 | c.ClientID = c.getStringFromIniSection(section, "client-id")
187 | }
188 |
189 | if section.HasKey("client-token") && c.ClientToken == "" {
190 | c.ClientToken = c.getStringFromIniSection(section, "client-token")
191 | }
192 |
193 | if section.HasKey("endpoint") && c.HTTPEndpoint == nil {
194 | endpoint := c.getStringFromIniSection(section, "endpoint")
195 | if err := c.setEndpoint(endpoint); err != nil {
196 | c.Logger.Error().Msgf("Blackfire: Unable to set from ini file %s, endpoint %s: %v", path, endpoint, err)
197 | }
198 | }
199 |
200 | if section.HasKey("timeout") && c.AgentTimeout == 0 {
201 | timeout := c.getStringFromIniSection(section, "timeout")
202 | var err error
203 | if c.AgentTimeout, err = parseSeconds(timeout); err != nil {
204 | c.Logger.Error().Msgf("Blackfire: Unable to set from ini file %s, timeout %s: %v", path, timeout, err)
205 | }
206 | }
207 | }
208 |
209 | func (c *Configuration) configureFromEnv() {
210 | if v := c.readEnvVar("BLACKFIRE_AGENT_SOCKET"); v != "" {
211 | c.AgentSocket = v
212 | }
213 |
214 | if v := c.readEnvVar("BLACKFIRE_QUERY"); v != "" {
215 | c.BlackfireQuery = v
216 | os.Unsetenv("BLACKFIRE_QUERY")
217 | }
218 |
219 | if v := c.readEnvVar("BLACKFIRE_CLIENT_ID"); v != "" {
220 | c.ClientID = v
221 | }
222 |
223 | if v := c.readEnvVar("BLACKFIRE_CLIENT_TOKEN"); v != "" {
224 | c.ClientToken = v
225 | }
226 |
227 | if v := c.readEnvVar("BLACKFIRE_SERVER_ID"); v != "" {
228 | c.ServerID = v
229 | }
230 |
231 | if v := c.readEnvVar("BLACKFIRE_SERVER_TOKEN"); v != "" {
232 | c.ServerToken = v
233 | }
234 |
235 | if v := c.readEnvVar("BLACKFIRE_ENDPOINT"); v != "" {
236 | if err := c.setEndpoint(v); err != nil {
237 | c.Logger.Error().Msgf("Blackfire: Unable to set from env var BLACKFIRE_ENDPOINT %s: %v", v, err)
238 | }
239 | }
240 |
241 | if v := c.readEnvVar("BLACKFIRE_PPROF_DUMP_DIR"); v != "" {
242 | absPath, err := filepath.Abs(v)
243 | if err != nil {
244 | c.Logger.Error().Msgf("Blackfire: Unable to set pprof dump dir to %v: %v", v, err)
245 | } else {
246 | c.PProfDumpDir = absPath
247 | }
248 | }
249 | }
250 |
251 | func (c *Configuration) load() error {
252 | c.loader.Do(func() {
253 | if c.Logger == nil {
254 | logger := NewLoggerFromEnvVars()
255 | c.Logger = &logger
256 | }
257 | c.configureFromEnv()
258 | // Used for test purposes
259 | if "1" != os.Getenv("BLACKFIRE_INTERNAL_IGNORE_INI") {
260 | c.configureFromIniFile()
261 | }
262 | c.configureFromDefaults()
263 | if c.err = c.validate(); c.err != nil {
264 | c.Logger.Warn().Err(c.err).Msg("Blackfire: Bad configuration")
265 | }
266 | })
267 | return c.err
268 | }
269 |
270 | func (c *Configuration) validate() error {
271 | if c.BlackfireQuery == "" {
272 | if c.ClientID == "" || c.ClientToken == "" {
273 | return errors.New("either BLACKFIRE_QUERY must be set, or client ID and client token must be set")
274 | }
275 | }
276 |
277 | if c.PProfDumpDir != "" {
278 | info, err := os.Stat(c.PProfDumpDir)
279 | if err != nil {
280 | return fmt.Errorf("Cannot dump pprof files to %v: %v", c.PProfDumpDir, err)
281 | }
282 | if !info.IsDir() {
283 | return fmt.Errorf("Cannot dump pprof files to %v: not a directory", c.PProfDumpDir)
284 | }
285 |
286 | // There's no 100% portable way to check for writability, so we just create
287 | // a temp zero-byte file and see if it succeeds.
288 | exePath, err := os.Executable()
289 | if err != nil {
290 | exePath = "go-unknown"
291 | } else {
292 | exePath = path.Base(exePath)
293 | }
294 | testPath := path.Join(c.PProfDumpDir, exePath+"-writability-test")
295 | // Delete it before starting, and make sure it gets deleted after
296 | os.Remove(testPath)
297 | defer os.Remove(testPath)
298 | if err = ioutil.WriteFile(testPath, []byte{}, 0644); err != nil {
299 | return fmt.Errorf("Cannot dump pprof files to %v: directory does not seem writable: %v", c.PProfDumpDir, err)
300 | }
301 | }
302 | return nil
303 | }
304 |
305 | func (c *Configuration) readEnvVar(name string) string {
306 | if v := os.Getenv(name); v != "" {
307 | c.Logger.Debug().Msgf("Blackfire: Read ENV var %s: %s", name, v)
308 | return v
309 | }
310 | return ""
311 | }
312 |
313 | func (c *Configuration) getStringFromIniSection(section *ini.Section, key string) string {
314 | if v := section.Key(key).String(); v != "" {
315 | c.Logger.Debug().Msgf("Blackfire: Read INI key %s: %s", key, v)
316 | return v
317 | }
318 | return ""
319 | }
320 |
321 | func parseSeconds(value string) (time.Duration, error) {
322 | re := regexp.MustCompile(`([0-9.]+)`)
323 | found := re.FindStringSubmatch(value)
324 |
325 | if len(found) == 0 {
326 | return 0, fmt.Errorf("%s: No seconds value found", value)
327 | }
328 |
329 | seconds, err := strconv.ParseFloat(found[1], 64)
330 | if err != nil {
331 | return 0, err
332 | }
333 | return time.Duration(float64(time.Second) * seconds), nil
334 | }
335 |
--------------------------------------------------------------------------------
/configuration_test.go:
--------------------------------------------------------------------------------
1 | package blackfire
2 |
3 | import (
4 | "net/url"
5 | "os"
6 | "path/filepath"
7 | "testing"
8 | "time"
9 |
10 | "github.com/rs/zerolog"
11 | . "gopkg.in/check.v1"
12 | )
13 |
14 | func Test(t *testing.T) { TestingT(t) }
15 |
16 | type BlackfireSuite struct{}
17 |
18 | var _ = Suite(&BlackfireSuite{})
19 |
20 | func URL(contents string) *url.URL {
21 | result, err := url.Parse(contents)
22 | if err != nil {
23 | panic(err)
24 | }
25 | return result
26 | }
27 |
28 | func newConfig() *Configuration {
29 | logger := NewLogger(filepath.Join(os.TempDir(), "blackfire-manual.log"), 3)
30 | return &Configuration{
31 | AgentSocket: "tcp://127.0.0.1:3333",
32 | AgentTimeout: time.Second * 3,
33 | BlackfireQuery: "blackfire_query_manual",
34 | ClientID: "client_id_manual",
35 | ClientToken: "client_token_manual",
36 | HTTPEndpoint: URL("https://blackfire.io/manual"),
37 | Logger: &logger,
38 | }
39 | }
40 |
41 | func newMixedConfig() *Configuration {
42 | config := newConfig()
43 |
44 | // Use default
45 | os.Unsetenv("BLACKFIRE_ENDPOINT")
46 | config.HTTPEndpoint = nil
47 |
48 | // Use env
49 | config.Logger = nil
50 |
51 | // Use ini
52 | config.AgentTimeout = 0
53 |
54 | return config
55 | }
56 |
57 | func setupEnv() {
58 | os.Setenv("BLACKFIRE_AGENT_SOCKET", "tcp://127.0.0.1:2222")
59 | os.Setenv("BLACKFIRE_QUERY", "blackfire_query_env")
60 | os.Setenv("BLACKFIRE_CLIENT_ID", "client_id_env")
61 | os.Setenv("BLACKFIRE_CLIENT_TOKEN", "client_token_env")
62 | os.Setenv("BLACKFIRE_ENDPOINT", "https://blackfire.io/env")
63 | os.Setenv("BLACKFIRE_LOG_FILE", "stderr")
64 | os.Setenv("BLACKFIRE_LOG_LEVEL", "2")
65 | }
66 |
67 | func unsetEnv() {
68 | os.Unsetenv("BLACKFIRE_AGENT_SOCKET")
69 | os.Unsetenv("BLACKFIRE_QUERY")
70 | os.Unsetenv("BLACKFIRE_CLIENT_ID")
71 | os.Unsetenv("BLACKFIRE_CLIENT_TOKEN")
72 | os.Unsetenv("BLACKFIRE_ENDPOINT")
73 | os.Unsetenv("BLACKFIRE_LOG_FILE")
74 | os.Unsetenv("BLACKFIRE_LOG_LEVEL")
75 | }
76 |
77 | func newConfiguration(config *Configuration) *Configuration {
78 | if config == nil {
79 | config = &Configuration{}
80 | }
81 | config.load()
82 | return config
83 | }
84 |
85 | func setIgnoreIni() {
86 | os.Setenv("BLACKFIRE_INTERNAL_IGNORE_INI", "1")
87 | }
88 |
89 | func unsetIgnoreIni() {
90 | os.Unsetenv("BLACKFIRE_INTERNAL_IGNORE_INI")
91 | }
92 |
93 | func (s *BlackfireSuite) TestConfigurationPrecedence(c *C) {
94 | setIgnoreIni()
95 | defer unsetIgnoreIni()
96 | defer unsetEnv()
97 |
98 | os.Setenv("BLACKFIRE_AGENT_SOCKET", "tcp://127.0.0.1:2222")
99 |
100 | config := newConfiguration(&Configuration{AgentSocket: "tcp://127.0.0.1:2424"})
101 |
102 | c.Assert("tcp://127.0.0.1:2222", Equals, config.AgentSocket)
103 | }
104 |
105 | func (s *BlackfireSuite) TestConfigurationDefaults(c *C) {
106 | setIgnoreIni()
107 | defer unsetIgnoreIni()
108 | config := newConfiguration(nil)
109 | c.Assert("https://blackfire.io", Equals, config.HTTPEndpoint.String())
110 | c.Assert(zerolog.ErrorLevel, Equals, config.Logger.GetLevel())
111 | c.Assert(time.Millisecond*250, Equals, config.AgentTimeout)
112 | }
113 |
114 | func (s *BlackfireSuite) TestConfigurationIniFile(c *C) {
115 | config := newConfiguration(&Configuration{ConfigFile: "fixtures/test_blackfire.ini"})
116 | c.Assert("https://blackfire.io/ini", Equals, config.HTTPEndpoint.String())
117 | c.Assert("ab6f24b1-3103-4503-9f68-93d4b3f10c7c", Equals, config.ClientID)
118 | c.Assert("ec4f5fb9f43ec7004b44fc2f217c944c324c6225efcf144c2cee65eb5c45754c", Equals, config.ClientToken)
119 | c.Assert(time.Second*1, Equals, config.AgentTimeout)
120 | }
121 |
122 | func (s *BlackfireSuite) TestConfigurationEnv(c *C) {
123 | setupEnv()
124 | setIgnoreIni()
125 | defer unsetEnv()
126 |
127 | config := newConfiguration(nil)
128 | c.Assert("tcp://127.0.0.1:2222", Equals, config.AgentSocket)
129 | c.Assert("blackfire_query_env", Equals, config.BlackfireQuery)
130 | c.Assert("client_id_env", Equals, config.ClientID)
131 | c.Assert("client_token_env", Equals, config.ClientToken)
132 | c.Assert("https://blackfire.io/env", Equals, config.HTTPEndpoint.String())
133 | c.Assert(zerolog.WarnLevel, Equals, config.Logger.GetLevel())
134 | c.Assert(time.Millisecond*250, Equals, config.AgentTimeout)
135 |
136 | setupEnv()
137 | unsetIgnoreIni()
138 | config = newConfiguration(&Configuration{ConfigFile: "fixtures/test_blackfire.ini"})
139 | c.Assert("tcp://127.0.0.1:2222", Equals, config.AgentSocket)
140 | c.Assert("blackfire_query_env", Equals, config.BlackfireQuery)
141 | c.Assert("client_id_env", Equals, config.ClientID)
142 | c.Assert("client_token_env", Equals, config.ClientToken)
143 | c.Assert("https://blackfire.io/env", Equals, config.HTTPEndpoint.String())
144 | c.Assert(zerolog.WarnLevel, Equals, config.Logger.GetLevel())
145 | c.Assert(time.Second*1, Equals, config.AgentTimeout)
146 | }
147 |
148 | func (s *BlackfireSuite) TestConfigurationManual(c *C) {
149 | config := newConfig()
150 | setIgnoreIni()
151 | config.load()
152 | c.Assert("tcp://127.0.0.1:3333", Equals, config.AgentSocket)
153 | c.Assert("blackfire_query_manual", Equals, config.BlackfireQuery)
154 | c.Assert("client_id_manual", Equals, config.ClientID)
155 | c.Assert("client_token_manual", Equals, config.ClientToken)
156 | c.Assert("https://blackfire.io/manual", Equals, config.HTTPEndpoint.String())
157 | c.Assert(zerolog.InfoLevel, Equals, config.Logger.GetLevel())
158 | c.Assert(time.Second*3, Equals, config.AgentTimeout)
159 |
160 | unsetIgnoreIni()
161 | config = newConfig()
162 | config.ConfigFile = "fixtures/test_blackfire.ini"
163 | config.load()
164 | c.Assert("tcp://127.0.0.1:3333", Equals, config.AgentSocket)
165 | c.Assert("blackfire_query_manual", Equals, config.BlackfireQuery)
166 | c.Assert("client_id_manual", Equals, config.ClientID)
167 | c.Assert("client_token_manual", Equals, config.ClientToken)
168 | c.Assert("https://blackfire.io/manual", Equals, config.HTTPEndpoint.String())
169 | c.Assert(zerolog.InfoLevel, Equals, config.Logger.GetLevel())
170 | c.Assert(time.Second*3, Equals, config.AgentTimeout)
171 | }
172 |
173 | func (s *BlackfireSuite) TestConfigurationMixed(c *C) {
174 | setIgnoreIni()
175 | setupEnv()
176 | defer unsetEnv()
177 |
178 | config := newMixedConfig()
179 | config.load()
180 | c.Assert("tcp://127.0.0.1:2222", Equals, config.AgentSocket)
181 | c.Assert("blackfire_query_env", Equals, config.BlackfireQuery)
182 | c.Assert("client_id_env", Equals, config.ClientID)
183 | c.Assert("client_token_env", Equals, config.ClientToken)
184 | c.Assert("https://blackfire.io", Equals, config.HTTPEndpoint.String())
185 | c.Assert(zerolog.WarnLevel, Equals, config.Logger.GetLevel())
186 | c.Assert(time.Millisecond*250, Equals, config.AgentTimeout)
187 |
188 | unsetIgnoreIni()
189 | setupEnv()
190 | config = newMixedConfig()
191 | config.ConfigFile = "fixtures/test2_blackfire.ini"
192 | config.load()
193 | c.Assert("tcp://127.0.0.1:2222", Equals, config.AgentSocket)
194 | c.Assert("blackfire_query_env", Equals, config.BlackfireQuery)
195 | c.Assert("client_id_env", Equals, config.ClientID)
196 | c.Assert("client_token_env", Equals, config.ClientToken)
197 | c.Assert("https://blackfire.io", Equals, config.HTTPEndpoint.String())
198 | c.Assert(zerolog.WarnLevel, Equals, config.Logger.GetLevel())
199 | c.Assert(time.Second*1, Equals, config.AgentTimeout)
200 | }
201 |
--------------------------------------------------------------------------------
/dashboard/.gitignore:
--------------------------------------------------------------------------------
1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
2 |
3 | # dependencies
4 | /node_modules
5 |
6 | # testing
7 | /coverage
8 |
9 | # production
10 | /build
11 | /dist
12 |
13 | npm-debug.log*
14 | yarn-debug.log*
15 | yarn-error.log*
16 |
--------------------------------------------------------------------------------
/dashboard/.ncurc.json:
--------------------------------------------------------------------------------
1 | {
2 | "upgrade": true,
3 | "format": "group",
4 | "interactive": true,
5 | "peer": true
6 | }
7 |
--------------------------------------------------------------------------------
/dashboard/.npmrc:
--------------------------------------------------------------------------------
1 | legacy-peer-deps=true
2 |
--------------------------------------------------------------------------------
/dashboard/config-overrides.js:
--------------------------------------------------------------------------------
1 | /*eslint-disable no-unused-vars*/
2 |
3 | const MiniCssExtractPlugin = require('mini-css-extract-plugin');
4 |
5 | // this tweaks the webpack configuration, thanks to react-app-rewired
6 | module.exports = function override(config, env) {
7 | config.output.filename = 'static/js/[name].js';
8 | config.output.chunkFilename = 'static/js/[name].js';
9 | config.optimization.splitChunks = false;
10 | config.optimization.runtimeChunk = false;
11 |
12 | config.plugins.forEach((plugin) => {
13 | if (plugin instanceof MiniCssExtractPlugin) {
14 | plugin.options.filename = 'static/css/[name].css';
15 | }
16 | });
17 |
18 | return config;
19 | };
20 |
--------------------------------------------------------------------------------
/dashboard/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "go-dashboard",
3 | "version": "0.1.0",
4 | "private": true,
5 | "dependencies": {
6 | "@testing-library/jest-dom": "^6.1.5",
7 | "@testing-library/react": "^14.1.2",
8 | "@testing-library/user-event": "^14.5.1",
9 | "es6-promise": "^4.2.8",
10 | "immutable": "^4.3.4",
11 | "keymirror": "^0.1.1",
12 | "moment": "^2.29.4",
13 | "react": "^18.2.0",
14 | "react-dom": "^18.2.0",
15 | "react-redux": "^9.0.4",
16 | "react-scripts": "^5.0.1",
17 | "redux": "^5.0.1",
18 | "redux-thunk": "^3.1.0",
19 | "whatwg-fetch": "^3.6.20"
20 | },
21 | "scripts": {
22 | "start": "react-app-rewired start --scripts-version react-scripts",
23 | "build": "react-app-rewired build --scripts-version react-scripts",
24 | "merge": "webpack --config packaging/webpack.config-merge.js",
25 | "test": "CI=true react-app-rewired test --scripts-version react-scripts",
26 | "eject": "react-scripts eject",
27 | "serve": "serve -s dist",
28 | "eslint": "eslint src packaging *.js",
29 | "eslint-fix": "eslint --fix src packaging *.js"
30 | },
31 | "eslintConfig": {
32 | "extends": "react-app"
33 | },
34 | "browserslist": {
35 | "production": [
36 | ">0.2%",
37 | "not dead",
38 | "not op_mini all"
39 | ],
40 | "development": [
41 | "last 1 chrome version",
42 | "last 1 firefox version",
43 | "last 1 safari version"
44 | ]
45 | },
46 | "devDependencies": {
47 | "eslint": "^8.56.0",
48 | "eslint-config-airbnb": "^19.0.4",
49 | "react-app-rewired": "^2.2.1",
50 | "serve": "^14.2.1",
51 | "uglifyjs-webpack-plugin": "^2.2.0",
52 | "webpack": "^5.89.0",
53 | "webpack-cli": "^5.1.4"
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/dashboard/packaging/packager.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | const fs = require('fs');
4 |
5 | const dir = `${__dirname}/..`;
6 |
7 | fs.mkdirSync(`${dir}/dist`, { recursive: true });
8 |
9 | fs.writeFileSync(`${dir}/dist/index.html`, fs.readFileSync(`${dir}/build/index.html`, { encoding: 'utf8' }).replace('', '').replace('', () => ``));
10 |
--------------------------------------------------------------------------------
/dashboard/packaging/webpack.config-merge.js:
--------------------------------------------------------------------------------
1 | const UglifyJsPlugin = require('uglifyjs-webpack-plugin');
2 | const path = require('path');
3 | const glob = require('glob');
4 |
5 | module.exports = {
6 | mode: 'production',
7 | entry: {
8 | 'bundle.js': glob.sync(`${__dirname}/../build/static/?(js|css)/*.?(js|css)`).map((f) => path.resolve(__dirname, f)),
9 | },
10 | output: {
11 | path: `${__dirname}/../build/merged`,
12 | filename: 'bundle.js',
13 | },
14 | module: {
15 | rules: [
16 | {
17 | test: /\.css$/,
18 | use: ['style-loader', 'css-loader'],
19 | },
20 | ],
21 | },
22 | optimization: {
23 | minimizer: [new UglifyJsPlugin()],
24 | },
25 | };
26 |
27 |
--------------------------------------------------------------------------------
/dashboard/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
12 | Blackfire Go Dashboard
13 |
14 |
15 |
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/dashboard/src/App.css:
--------------------------------------------------------------------------------
1 | body {
2 | font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
3 | font-size: 14px;
4 | background-color: #DDDDDD;
5 | }
6 |
7 | #root {
8 | margin: 0 auto;
9 | width: 800px;
10 | display: flex;
11 | flex-direction: column;
12 | background-color: #e5e5e5;
13 | min-height: 100vh;
14 | }
15 |
16 | a {
17 | color: #2da1bf;
18 | text-decoration: none;
19 | }
20 |
21 | .App-header {
22 | background-color: #323232;
23 | display: flex;
24 | flex-direction: column;
25 | align-items: center;
26 | justify-content: center;
27 | font-size: calc(10px + 2vmin);
28 | color: white;
29 | }
30 |
31 | .wrapper {
32 | width: 500px;
33 | margin: 0 auto;
34 | position: relative;
35 | padding: 20px 0;
36 | line-height: 35px;
37 | flex: 1;
38 | }
39 |
40 | .App-footer {
41 | bottom: 0;
42 | width: 100%;
43 | background-color: #F5F5F5;
44 | }
45 |
46 | .App-footer a {
47 | color: #e03c31;
48 | }
49 |
50 | .error {
51 | border: 1px solid #e03c31;
52 | border-radius: 5px;
53 | margin: 15px 0;
54 | padding: 5px 10px;
55 | }
56 |
57 | .App-link {
58 | color: #61dafb;
59 | }
60 |
61 | pre {
62 | line-height: 1em;
63 | min-height: 100px;
64 | max-height: 500px;
65 | overflow: scroll;
66 | }
67 |
--------------------------------------------------------------------------------
/dashboard/src/App.js:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import './App.css';
3 | import { Provider } from 'react-redux';
4 | import store from './redux/stores/configureStore';
5 | import BlackfireLogo from './Icon/BlackfireLogo';
6 | import Content from './Content';
7 |
8 | function App() {
9 | return (
10 |
11 |
16 |
17 |
25 |
26 | );
27 | }
28 |
29 | export default App;
30 |
--------------------------------------------------------------------------------
/dashboard/src/App.test.js:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { render } from '@testing-library/react';
3 | import App from './App';
4 |
5 | /*eslint-disable no-undef*/
6 |
7 | test('renders troubleshooting link', () => {
8 | const { getByText } = render();
9 | const linkElement = getByText(/Troubleshooting/i);
10 | expect(linkElement).toBeInTheDocument();
11 | });
12 |
--------------------------------------------------------------------------------
/dashboard/src/Content/Error.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from 'react';
2 | import PropTypes from 'prop-types';
3 | import { connect } from 'react-redux';
4 | import { bindActionCreators } from 'redux';
5 | import * as DashboardActions from '../redux/actions/DashboardActions';
6 |
7 | class Error extends Component {
8 | timeout;
9 |
10 | componentDidMount() {
11 | if (this.props.error) {
12 | this._setTimeout();
13 | }
14 | }
15 |
16 | componentDidUpdate(prevProps) {
17 | if (prevProps.error !== this.props.error) {
18 | this._clearTimeout();
19 | if (this.props.error) {
20 | this._setTimeout();
21 | }
22 | }
23 | }
24 |
25 | componentWillUnmount() {
26 | this._clearTimeout();
27 | }
28 |
29 | _setTimeout() {
30 | this.timeout = setTimeout(() => {
31 | this.props.actions.clearError();
32 | this.timeout = null;
33 | }, 10000);
34 | }
35 |
36 | _clearTimeout() {
37 | if (this.timeout) {
38 | clearTimeout(this.timeout);
39 | }
40 | this.timeout = null;
41 | }
42 |
43 | render() {
44 | const { error } = this.props;
45 |
46 | if (!error) {
47 | return null;
48 | }
49 |
50 | return (
51 |
52 | {`${error.title} (${ error.detail})`}
53 |
54 | );
55 | }
56 | }
57 |
58 | Error.defaultProps = {
59 | error: null,
60 | };
61 |
62 | Error.propTypes = {
63 | actions: PropTypes.shape({
64 | clearError: PropTypes.func.isRequired,
65 | }).isRequired,
66 | error: PropTypes.shape({
67 | status: PropTypes.number.isRequired,
68 | title: PropTypes.string.isRequired,
69 | detail: PropTypes.string.isRequired,
70 | }),
71 | };
72 |
73 | function mapDispatchToProps(dispatch) {
74 | return {
75 | actions: bindActionCreators(DashboardActions, dispatch),
76 | };
77 | }
78 |
79 | export default connect((state) => ({
80 | error: state.DashboardReducer.get('error'),
81 | }), mapDispatchToProps)(Error);
82 |
--------------------------------------------------------------------------------
/dashboard/src/Content/ProfileList.js:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import PropTypes from 'prop-types';
3 | import { connect } from 'react-redux';
4 | import Timeago from '../Timeago';
5 |
6 | function upperCaseFirst(word) {
7 | if (!word || !word.length || word.length < 1) {
8 | return word;
9 | }
10 |
11 | return `${word[0].toUpperCase()}${word.substr(1)}`;
12 | }
13 |
14 | function ProfileList({ profiles }) {
15 | return (
16 |
17 |
{'Profiles:'}
18 | {profiles.map((profile) => (
19 |
26 | ))}
27 | {profiles.length === 0 ?
{'No profiles yet'} : null}
28 |
35 |
{'Configuration:'}
36 |
37 |
{`Profiling is ${profiling_enabled ? 'enabled' : 'disabled'}`}
38 | {profiling_enabled &&
}
39 |
40 |
41 | {`Sample rate: ${profiling_sample_rate} Hz`}
42 |
43 |
{'Control:'}
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 | {action_pending &&
}
54 |
55 |
56 |
57 |