main
slaventius@odnookno.info
2 years ago
parent
2595ce9549
commit
518619803a
402 changed files with 220874 additions and 19 deletions
@ -0,0 +1,47 @@ |
||||
package logger |
||||
|
||||
import ( |
||||
"log" |
||||
"time" |
||||
|
||||
"github.com/evalphobia/logrus_sentry" |
||||
"github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
type Logger struct { |
||||
*logrus.Logger |
||||
} |
||||
|
||||
func NewLogger(appSource string, dsn string) *Logger { |
||||
logger := logrus.New() |
||||
logger.SetReportCaller(true) // Добавим отображение строки
|
||||
|
||||
//
|
||||
if dsn == "" { |
||||
logger.Warn("sentry dsn is empty, its use is not possible") |
||||
} else { |
||||
if hook, err := logrus_sentry.NewSentryHook(dsn, []logrus.Level{ |
||||
logrus.PanicLevel, |
||||
logrus.FatalLevel, |
||||
logrus.ErrorLevel, |
||||
logrus.InfoLevel, |
||||
logrus.WarnLevel, |
||||
}); err != nil { |
||||
log.Fatal(err) |
||||
} else { |
||||
//
|
||||
tags := make(map[string]string) |
||||
tags["app"] = appSource |
||||
|
||||
hook.Timeout = 1 * time.Second |
||||
hook.SetTagsContext(tags) |
||||
|
||||
//
|
||||
logger.Hooks.Add(hook) |
||||
} |
||||
} |
||||
|
||||
return &Logger{ |
||||
Logger: logger, |
||||
} |
||||
} |
||||
@ -0,0 +1,373 @@ |
||||
Mozilla Public License Version 2.0 |
||||
================================== |
||||
|
||||
1. Definitions |
||||
-------------- |
||||
|
||||
1.1. "Contributor" |
||||
means each individual or legal entity that creates, contributes to |
||||
the creation of, or owns Covered Software. |
||||
|
||||
1.2. "Contributor Version" |
||||
means the combination of the Contributions of others (if any) used |
||||
by a Contributor and that particular Contributor's Contribution. |
||||
|
||||
1.3. "Contribution" |
||||
means Covered Software of a particular Contributor. |
||||
|
||||
1.4. "Covered Software" |
||||
means Source Code Form to which the initial Contributor has attached |
||||
the notice in Exhibit A, the Executable Form of such Source Code |
||||
Form, and Modifications of such Source Code Form, in each case |
||||
including portions thereof. |
||||
|
||||
1.5. "Incompatible With Secondary Licenses" |
||||
means |
||||
|
||||
(a) that the initial Contributor has attached the notice described |
||||
in Exhibit B to the Covered Software; or |
||||
|
||||
(b) that the Covered Software was made available under the terms of |
||||
version 1.1 or earlier of the License, but not also under the |
||||
terms of a Secondary License. |
||||
|
||||
1.6. "Executable Form" |
||||
means any form of the work other than Source Code Form. |
||||
|
||||
1.7. "Larger Work" |
||||
means a work that combines Covered Software with other material, in |
||||
a separate file or files, that is not Covered Software. |
||||
|
||||
1.8. "License" |
||||
means this document. |
||||
|
||||
1.9. "Licensable" |
||||
means having the right to grant, to the maximum extent possible, |
||||
whether at the time of the initial grant or subsequently, any and |
||||
all of the rights conveyed by this License. |
||||
|
||||
1.10. "Modifications" |
||||
means any of the following: |
||||
|
||||
(a) any file in Source Code Form that results from an addition to, |
||||
deletion from, or modification of the contents of Covered |
||||
Software; or |
||||
|
||||
(b) any new file in Source Code Form that contains any Covered |
||||
Software. |
||||
|
||||
1.11. "Patent Claims" of a Contributor |
||||
means any patent claim(s), including without limitation, method, |
||||
process, and apparatus claims, in any patent Licensable by such |
||||
Contributor that would be infringed, but for the grant of the |
||||
License, by the making, using, selling, offering for sale, having |
||||
made, import, or transfer of either its Contributions or its |
||||
Contributor Version. |
||||
|
||||
1.12. "Secondary License" |
||||
means either the GNU General Public License, Version 2.0, the GNU |
||||
Lesser General Public License, Version 2.1, the GNU Affero General |
||||
Public License, Version 3.0, or any later versions of those |
||||
licenses. |
||||
|
||||
1.13. "Source Code Form" |
||||
means the form of the work preferred for making modifications. |
||||
|
||||
1.14. "You" (or "Your") |
||||
means an individual or a legal entity exercising rights under this |
||||
License. For legal entities, "You" includes any entity that |
||||
controls, is controlled by, or is under common control with You. For |
||||
purposes of this definition, "control" means (a) the power, direct |
||||
or indirect, to cause the direction or management of such entity, |
||||
whether by contract or otherwise, or (b) ownership of more than |
||||
fifty percent (50%) of the outstanding shares or beneficial |
||||
ownership of such entity. |
||||
|
||||
2. License Grants and Conditions |
||||
-------------------------------- |
||||
|
||||
2.1. Grants |
||||
|
||||
Each Contributor hereby grants You a world-wide, royalty-free, |
||||
non-exclusive license: |
||||
|
||||
(a) under intellectual property rights (other than patent or trademark) |
||||
Licensable by such Contributor to use, reproduce, make available, |
||||
modify, display, perform, distribute, and otherwise exploit its |
||||
Contributions, either on an unmodified basis, with Modifications, or |
||||
as part of a Larger Work; and |
||||
|
||||
(b) under Patent Claims of such Contributor to make, use, sell, offer |
||||
for sale, have made, import, and otherwise transfer either its |
||||
Contributions or its Contributor Version. |
||||
|
||||
2.2. Effective Date |
||||
|
||||
The licenses granted in Section 2.1 with respect to any Contribution |
||||
become effective for each Contribution on the date the Contributor first |
||||
distributes such Contribution. |
||||
|
||||
2.3. Limitations on Grant Scope |
||||
|
||||
The licenses granted in this Section 2 are the only rights granted under |
||||
this License. No additional rights or licenses will be implied from the |
||||
distribution or licensing of Covered Software under this License. |
||||
Notwithstanding Section 2.1(b) above, no patent license is granted by a |
||||
Contributor: |
||||
|
||||
(a) for any code that a Contributor has removed from Covered Software; |
||||
or |
||||
|
||||
(b) for infringements caused by: (i) Your and any other third party's |
||||
modifications of Covered Software, or (ii) the combination of its |
||||
Contributions with other software (except as part of its Contributor |
||||
Version); or |
||||
|
||||
(c) under Patent Claims infringed by Covered Software in the absence of |
||||
its Contributions. |
||||
|
||||
This License does not grant any rights in the trademarks, service marks, |
||||
or logos of any Contributor (except as may be necessary to comply with |
||||
the notice requirements in Section 3.4). |
||||
|
||||
2.4. Subsequent Licenses |
||||
|
||||
No Contributor makes additional grants as a result of Your choice to |
||||
distribute the Covered Software under a subsequent version of this |
||||
License (see Section 10.2) or under the terms of a Secondary License (if |
||||
permitted under the terms of Section 3.3). |
||||
|
||||
2.5. Representation |
||||
|
||||
Each Contributor represents that the Contributor believes its |
||||
Contributions are its original creation(s) or it has sufficient rights |
||||
to grant the rights to its Contributions conveyed by this License. |
||||
|
||||
2.6. Fair Use |
||||
|
||||
This License is not intended to limit any rights You have under |
||||
applicable copyright doctrines of fair use, fair dealing, or other |
||||
equivalents. |
||||
|
||||
2.7. Conditions |
||||
|
||||
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted |
||||
in Section 2.1. |
||||
|
||||
3. Responsibilities |
||||
------------------- |
||||
|
||||
3.1. Distribution of Source Form |
||||
|
||||
All distribution of Covered Software in Source Code Form, including any |
||||
Modifications that You create or to which You contribute, must be under |
||||
the terms of this License. You must inform recipients that the Source |
||||
Code Form of the Covered Software is governed by the terms of this |
||||
License, and how they can obtain a copy of this License. You may not |
||||
attempt to alter or restrict the recipients' rights in the Source Code |
||||
Form. |
||||
|
||||
3.2. Distribution of Executable Form |
||||
|
||||
If You distribute Covered Software in Executable Form then: |
||||
|
||||
(a) such Covered Software must also be made available in Source Code |
||||
Form, as described in Section 3.1, and You must inform recipients of |
||||
the Executable Form how they can obtain a copy of such Source Code |
||||
Form by reasonable means in a timely manner, at a charge no more |
||||
than the cost of distribution to the recipient; and |
||||
|
||||
(b) You may distribute such Executable Form under the terms of this |
||||
License, or sublicense it under different terms, provided that the |
||||
license for the Executable Form does not attempt to limit or alter |
||||
the recipients' rights in the Source Code Form under this License. |
||||
|
||||
3.3. Distribution of a Larger Work |
||||
|
||||
You may create and distribute a Larger Work under terms of Your choice, |
||||
provided that You also comply with the requirements of this License for |
||||
the Covered Software. If the Larger Work is a combination of Covered |
||||
Software with a work governed by one or more Secondary Licenses, and the |
||||
Covered Software is not Incompatible With Secondary Licenses, this |
||||
License permits You to additionally distribute such Covered Software |
||||
under the terms of such Secondary License(s), so that the recipient of |
||||
the Larger Work may, at their option, further distribute the Covered |
||||
Software under the terms of either this License or such Secondary |
||||
License(s). |
||||
|
||||
3.4. Notices |
||||
|
||||
You may not remove or alter the substance of any license notices |
||||
(including copyright notices, patent notices, disclaimers of warranty, |
||||
or limitations of liability) contained within the Source Code Form of |
||||
the Covered Software, except that You may alter any license notices to |
||||
the extent required to remedy known factual inaccuracies. |
||||
|
||||
3.5. Application of Additional Terms |
||||
|
||||
You may choose to offer, and to charge a fee for, warranty, support, |
||||
indemnity or liability obligations to one or more recipients of Covered |
||||
Software. However, You may do so only on Your own behalf, and not on |
||||
behalf of any Contributor. You must make it absolutely clear that any |
||||
such warranty, support, indemnity, or liability obligation is offered by |
||||
You alone, and You hereby agree to indemnify every Contributor for any |
||||
liability incurred by such Contributor as a result of warranty, support, |
||||
indemnity or liability terms You offer. You may include additional |
||||
disclaimers of warranty and limitations of liability specific to any |
||||
jurisdiction. |
||||
|
||||
4. Inability to Comply Due to Statute or Regulation |
||||
--------------------------------------------------- |
||||
|
||||
If it is impossible for You to comply with any of the terms of this |
||||
License with respect to some or all of the Covered Software due to |
||||
statute, judicial order, or regulation then You must: (a) comply with |
||||
the terms of this License to the maximum extent possible; and (b) |
||||
describe the limitations and the code they affect. Such description must |
||||
be placed in a text file included with all distributions of the Covered |
||||
Software under this License. Except to the extent prohibited by statute |
||||
or regulation, such description must be sufficiently detailed for a |
||||
recipient of ordinary skill to be able to understand it. |
||||
|
||||
5. Termination |
||||
-------------- |
||||
|
||||
5.1. The rights granted under this License will terminate automatically |
||||
if You fail to comply with any of its terms. However, if You become |
||||
compliant, then the rights granted under this License from a particular |
||||
Contributor are reinstated (a) provisionally, unless and until such |
||||
Contributor explicitly and finally terminates Your grants, and (b) on an |
||||
ongoing basis, if such Contributor fails to notify You of the |
||||
non-compliance by some reasonable means prior to 60 days after You have |
||||
come back into compliance. Moreover, Your grants from a particular |
||||
Contributor are reinstated on an ongoing basis if such Contributor |
||||
notifies You of the non-compliance by some reasonable means, this is the |
||||
first time You have received notice of non-compliance with this License |
||||
from such Contributor, and You become compliant prior to 30 days after |
||||
Your receipt of the notice. |
||||
|
||||
5.2. If You initiate litigation against any entity by asserting a patent |
||||
infringement claim (excluding declaratory judgment actions, |
||||
counter-claims, and cross-claims) alleging that a Contributor Version |
||||
directly or indirectly infringes any patent, then the rights granted to |
||||
You by any and all Contributors for the Covered Software under Section |
||||
2.1 of this License shall terminate. |
||||
|
||||
5.3. In the event of termination under Sections 5.1 or 5.2 above, all |
||||
end user license agreements (excluding distributors and resellers) which |
||||
have been validly granted by You or Your distributors under this License |
||||
prior to termination shall survive termination. |
||||
|
||||
************************************************************************ |
||||
* * |
||||
* 6. Disclaimer of Warranty * |
||||
* ------------------------- * |
||||
* * |
||||
* Covered Software is provided under this License on an "as is" * |
||||
* basis, without warranty of any kind, either expressed, implied, or * |
||||
* statutory, including, without limitation, warranties that the * |
||||
* Covered Software is free of defects, merchantable, fit for a * |
||||
* particular purpose or non-infringing. The entire risk as to the * |
||||
* quality and performance of the Covered Software is with You. * |
||||
* Should any Covered Software prove defective in any respect, You * |
||||
* (not any Contributor) assume the cost of any necessary servicing, * |
||||
* repair, or correction. This disclaimer of warranty constitutes an * |
||||
* essential part of this License. No use of any Covered Software is * |
||||
* authorized under this License except under this disclaimer. * |
||||
* * |
||||
************************************************************************ |
||||
|
||||
************************************************************************ |
||||
* * |
||||
* 7. Limitation of Liability * |
||||
* -------------------------- * |
||||
* * |
||||
* Under no circumstances and under no legal theory, whether tort * |
||||
* (including negligence), contract, or otherwise, shall any * |
||||
* Contributor, or anyone who distributes Covered Software as * |
||||
* permitted above, be liable to You for any direct, indirect, * |
||||
* special, incidental, or consequential damages of any character * |
||||
* including, without limitation, damages for lost profits, loss of * |
||||
* goodwill, work stoppage, computer failure or malfunction, or any * |
||||
* and all other commercial damages or losses, even if such party * |
||||
* shall have been informed of the possibility of such damages. This * |
||||
* limitation of liability shall not apply to liability for death or * |
||||
* personal injury resulting from such party's negligence to the * |
||||
* extent applicable law prohibits such limitation. Some * |
||||
* jurisdictions do not allow the exclusion or limitation of * |
||||
* incidental or consequential damages, so this exclusion and * |
||||
* limitation may not apply to You. * |
||||
* * |
||||
************************************************************************ |
||||
|
||||
8. Litigation |
||||
------------- |
||||
|
||||
Any litigation relating to this License may be brought only in the |
||||
courts of a jurisdiction where the defendant maintains its principal |
||||
place of business and such litigation shall be governed by laws of that |
||||
jurisdiction, without reference to its conflict-of-law provisions. |
||||
Nothing in this Section shall prevent a party's ability to bring |
||||
cross-claims or counter-claims. |
||||
|
||||
9. Miscellaneous |
||||
---------------- |
||||
|
||||
This License represents the complete agreement concerning the subject |
||||
matter hereof. If any provision of this License is held to be |
||||
unenforceable, such provision shall be reformed only to the extent |
||||
necessary to make it enforceable. Any law or regulation which provides |
||||
that the language of a contract shall be construed against the drafter |
||||
shall not be used to construe this License against a Contributor. |
||||
|
||||
10. Versions of the License |
||||
--------------------------- |
||||
|
||||
10.1. New Versions |
||||
|
||||
Mozilla Foundation is the license steward. Except as provided in Section |
||||
10.3, no one other than the license steward has the right to modify or |
||||
publish new versions of this License. Each version will be given a |
||||
distinguishing version number. |
||||
|
||||
10.2. Effect of New Versions |
||||
|
||||
You may distribute the Covered Software under the terms of the version |
||||
of the License under which You originally received the Covered Software, |
||||
or under the terms of any subsequent version published by the license |
||||
steward. |
||||
|
||||
10.3. Modified Versions |
||||
|
||||
If you create software not governed by this License, and you want to |
||||
create a new license for such software, you may create and use a |
||||
modified version of this License if you rename the license and remove |
||||
any references to the name of the license steward (except to note that |
||||
such modified license differs from this License). |
||||
|
||||
10.4. Distributing Source Code Form that is Incompatible With Secondary |
||||
Licenses |
||||
|
||||
If You choose to distribute Source Code Form that is Incompatible With |
||||
Secondary Licenses under the terms of this version of the License, the |
||||
notice described in Exhibit B of this License must be attached. |
||||
|
||||
Exhibit A - Source Code Form License Notice |
||||
------------------------------------------- |
||||
|
||||
This Source Code Form is subject to the terms of the Mozilla Public |
||||
License, v. 2.0. If a copy of the MPL was not distributed with this |
||||
file, You can obtain one at http://mozilla.org/MPL/2.0/. |
||||
|
||||
If it is not possible or desirable to put the notice in a particular |
||||
file, then You may include the notice in a location (such as a LICENSE |
||||
file in a relevant directory) where a recipient would be likely to look |
||||
for such a notice. |
||||
|
||||
You may add additional accurate notices of copyright ownership. |
||||
|
||||
Exhibit B - "Incompatible With Secondary Licenses" Notice |
||||
--------------------------------------------------------- |
||||
|
||||
This Source Code Form is "Incompatible With Secondary Licenses", as |
||||
defined by the Mozilla Public License, v. 2.0. |
||||
@ -0,0 +1,69 @@ |
||||
# GoCertifi: SSL Certificates for Golang |
||||
|
||||
This Go package contains a CA bundle that you can reference in your Go code. |
||||
This is useful for systems that do not have CA bundles that Golang can find |
||||
itself, or where a uniform set of CAs is valuable. |
||||
|
||||
This is the same CA bundle that ships with the |
||||
[Python Requests](https://github.com/kennethreitz/requests) library, and is a |
||||
Golang specific port of [certifi](https://github.com/kennethreitz/certifi). The |
||||
CA bundle is derived from Mozilla's canonical set. |
||||
|
||||
## Usage |
||||
|
||||
You can use the `gocertifi` package as follows: |
||||
|
||||
```go |
||||
import "github.com/certifi/gocertifi" |
||||
|
||||
certPool, err := gocertifi.CACerts() |
||||
``` |
||||
|
||||
You can use the returned `*x509.CertPool` as part of an HTTP transport, for example: |
||||
|
||||
```go |
||||
import ( |
||||
"net/http" |
||||
"crypto/tls" |
||||
) |
||||
|
||||
// Setup an HTTP client with a custom transport |
||||
transport := &http.Transport{ |
||||
Proxy: ProxyFromEnvironment, |
||||
DialContext: (&net.Dialer{ |
||||
Timeout: 30 * time.Second, |
||||
KeepAlive: 30 * time.Second, |
||||
DualStack: true, |
||||
}).DialContext, |
||||
ForceAttemptHTTP2: true, |
||||
MaxIdleConns: 100, |
||||
IdleConnTimeout: 90 * time.Second, |
||||
TLSHandshakeTimeout: 10 * time.Second, |
||||
ExpectContinueTimeout: 1 * time.Second, |
||||
} |
||||
// or, starting with go1.13 simply use: |
||||
// transport := http.DefaultTransport.(*http.Transport).Clone() |
||||
|
||||
transport.TLSClientConfig = &tls.Config{RootCAs: certPool} |
||||
client := &http.Client{Transport: transport} |
||||
|
||||
// Make an HTTP request using our custom transport |
||||
resp, err := client.Get("https://example.com") |
||||
``` |
||||
|
||||
## Detailed Documentation |
||||
|
||||
Import as follows: |
||||
|
||||
```go |
||||
import "github.com/certifi/gocertifi" |
||||
``` |
||||
|
||||
### Functions |
||||
|
||||
```go |
||||
func CACerts() (*x509.CertPool, error) |
||||
``` |
||||
CACerts builds an X.509 certificate pool containing the Mozilla CA Certificate |
||||
bundle. This can't actually error and always returns successfully with `nil` |
||||
as the error. This will be replaced in `v2` to only return the `CertPool`. |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,17 @@ |
||||
sudo: false |
||||
language: go |
||||
go: |
||||
- 1.10.x |
||||
- 1.x |
||||
- tip |
||||
matrix: |
||||
allow_failures: |
||||
- go: tip |
||||
before_install: |
||||
- go get github.com/axw/gocov/gocov |
||||
- go get github.com/mattn/goveralls |
||||
- go get golang.org/x/tools/cmd/cover |
||||
- test -z "$(gofmt -s -l . | tee /dev/stderr)" |
||||
- go tool vet -all -structtags -shadow . |
||||
script: |
||||
- $HOME/gopath/bin/goveralls -service=travis-ci |
||||
@ -0,0 +1,21 @@ |
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 logrus_sentry Authors |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
@ -0,0 +1,163 @@ |
||||
Sentry Hook for Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:" /> |
||||
---- |
||||
|
||||
[![GoDoc][1]][2] [![Release][5]][6] [![Build Status][7]][8] [![Coverage Status][9]][10] [![Go Report Card][13]][14] [![Code Climate][19]][20] [![BCH compliance][21]][22] |
||||
|
||||
[1]: https://godoc.org/github.com/evalphobia/logrus_sentry?status.svg |
||||
[2]: https://godoc.org/github.com/evalphobia/logrus_sentry |
||||
[4]: LICENSE.md |
||||
[5]: https://img.shields.io/github/release/evalphobia/logrus_sentry.svg |
||||
[6]: https://github.com/evalphobia/logrus_sentry/releases/latest |
||||
[7]: https://travis-ci.org/evalphobia/logrus_sentry.svg?branch=master |
||||
[8]: https://travis-ci.org/evalphobia/logrus_sentry |
||||
[9]: https://coveralls.io/repos/evalphobia/logrus_sentry/badge.svg?branch=master&service=github |
||||
[10]: https://coveralls.io/github/evalphobia/logrus_sentry?branch=master |
||||
[11]: https://codecov.io/github/evalphobia/logrus_sentry/coverage.svg?branch=master |
||||
[12]: https://codecov.io/github/evalphobia/logrus_sentry?branch=master |
||||
[13]: https://goreportcard.com/badge/github.com/evalphobia/logrus_sentry |
||||
[14]: https://goreportcard.com/report/github.com/evalphobia/logrus_sentry |
||||
[15]: https://img.shields.io/github/downloads/evalphobia/logrus_sentry/total.svg?maxAge=1800 |
||||
[16]: https://github.com/evalphobia/logrus_sentry/releases |
||||
[17]: https://img.shields.io/github/stars/evalphobia/logrus_sentry.svg |
||||
[18]: https://github.com/evalphobia/logrus_sentry/stargazers |
||||
[19]: https://codeclimate.com/github/evalphobia/logrus_sentry/badges/gpa.svg |
||||
[20]: https://codeclimate.com/github/evalphobia/logrus_sentry |
||||
[21]: https://bettercodehub.com/edge/badge/evalphobia/logrus_sentry?branch=master |
||||
[22]: https://bettercodehub.com/ |
||||
|
||||
|
||||
[Sentry](https://getsentry.com) provides both self-hosted and hosted |
||||
solutions for exception tracking. |
||||
Both client and server are |
||||
[open source](https://github.com/getsentry/sentry). |
||||
|
||||
## Usage |
||||
|
||||
Every sentry application defined on the server gets a different |
||||
[DSN](https://www.getsentry.com/docs/). In the example below replace |
||||
`YOUR_DSN` with the one created for your application. |
||||
|
||||
```go |
||||
import ( |
||||
"github.com/sirupsen/logrus" |
||||
"github.com/evalphobia/logrus_sentry" |
||||
) |
||||
|
||||
func main() { |
||||
log := logrus.New() |
||||
hook, err := logrus_sentry.NewSentryHook(YOUR_DSN, []logrus.Level{ |
||||
logrus.PanicLevel, |
||||
logrus.FatalLevel, |
||||
logrus.ErrorLevel, |
||||
}) |
||||
|
||||
if err == nil { |
||||
log.Hooks.Add(hook) |
||||
} |
||||
} |
||||
``` |
||||
|
||||
If you wish to initialize a SentryHook with tags, you can use the `NewWithTagsSentryHook` constructor to provide default tags: |
||||
|
||||
```go |
||||
tags := map[string]string{ |
||||
"site": "example.com", |
||||
} |
||||
levels := []logrus.Level{ |
||||
logrus.PanicLevel, |
||||
logrus.FatalLevel, |
||||
logrus.ErrorLevel, |
||||
} |
||||
hook, err := logrus_sentry.NewWithTagsSentryHook(YOUR_DSN, tags, levels) |
||||
|
||||
``` |
||||
|
||||
If you wish to initialize a SentryHook with an already initialized raven client, you can use |
||||
the `NewWithClientSentryHook` constructor: |
||||
|
||||
```go |
||||
import ( |
||||
"github.com/sirupsen/logrus" |
||||
"github.com/evalphobia/logrus_sentry" |
||||
"github.com/getsentry/raven-go" |
||||
) |
||||
|
||||
func main() { |
||||
log := logrus.New() |
||||
|
||||
client, err := raven.New(YOUR_DSN) |
||||
if err != nil { |
||||
log.Fatal(err) |
||||
} |
||||
|
||||
hook, err := logrus_sentry.NewWithClientSentryHook(client, []logrus.Level{ |
||||
logrus.PanicLevel, |
||||
logrus.FatalLevel, |
||||
logrus.ErrorLevel, |
||||
}) |
||||
|
||||
if err == nil { |
||||
log.Hooks.Add(hook) |
||||
} |
||||
} |
||||
|
||||
hook, err := NewWithClientSentryHook(client, []logrus.Level{ |
||||
logrus.ErrorLevel, |
||||
}) |
||||
``` |
||||
|
||||
## Special fields |
||||
|
||||
Some logrus fields have a special meaning in this hook, and they will be especially processed by Sentry. |
||||
|
||||
|
||||
| Field key | Description | |
||||
| ------------- | ------------- | |
||||
| `event_id` | Each logged event is identified by the `event_id`, which is hexadecimal string representing a UUID4 value. You can manually specify the identifier of a log event by supplying this field. The `event_id` string should be in one of the following UUID format: `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx` and `urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`)| |
||||
| `user_name` | Name of the user who is in the context of the event | |
||||
| `user_email` | Email of the user who is in the context of the event | |
||||
| `user_id` | ID of the user who is in the context of the event | |
||||
| `user_ip` | IP of the user who is in the context of the event | |
||||
| `server_name` | Also known as hostname, it is the name of the server which is logging the event (hostname.example.com) | |
||||
| `tags` | `tags` are `raven.Tags` struct from `github.com/getsentry/raven-go` and override default tags data | |
||||
| `fingerprint` | `fingerprint` is an string array, that allows you to affect sentry's grouping of events as detailed in the [sentry documentation](https://docs.sentry.io/learn/rollups/#customize-grouping-with-fingerprints) | |
||||
| `logger` | `logger` is the part of the application which is logging the event. In go this usually means setting it to the name of the package. | |
||||
| `http_request` | `http_request` is the in-coming request(*http.Request). The detailed request data are sent to Sentry. | |
||||
|
||||
## Timeout |
||||
|
||||
`Timeout` is the time the sentry hook will wait for a response |
||||
from the sentry server. |
||||
|
||||
If this time elapses with no response from |
||||
the server an error will be returned. |
||||
|
||||
If `Timeout` is set to 0 the SentryHook will not wait for a reply |
||||
and will assume a correct delivery. |
||||
|
||||
The SentryHook has a default timeout of `100 milliseconds` when created |
||||
with a call to `NewSentryHook`. This can be changed by assigning a value to the `Timeout` field: |
||||
|
||||
```go |
||||
hook, _ := logrus_sentry.NewSentryHook(...) |
||||
hook.Timeout = 20*time.Second |
||||
``` |
||||
|
||||
## Enabling Stacktraces |
||||
|
||||
By default the hook will not send any stacktraces. However, this can be enabled |
||||
with: |
||||
|
||||
```go |
||||
hook, _ := logrus_sentry.NewSentryHook(...) |
||||
hook.StacktraceConfiguration.Enable = true |
||||
``` |
||||
|
||||
Subsequent calls to `logger.Error` and above will create a stacktrace. |
||||
|
||||
Other configuration options are: |
||||
- `StacktraceConfiguration.Level` the logrus level at which to start capturing stacktraces. |
||||
- `StacktraceConfiguration.Skip` how many stack frames to skip before stacktrace starts recording. |
||||
- `StacktraceConfiguration.Context` the number of lines to include around a stack frame for context. |
||||
- `StacktraceConfiguration.InAppPrefixes` the prefixes that will be matched against the stack frame to identify it as in_app |
||||
- `StacktraceConfiguration.IncludeErrorBreadcrumb` whether to create a breadcrumb with the full text of error |
||||
@ -0,0 +1,137 @@ |
||||
package logrus_sentry |
||||
|
||||
import ( |
||||
"net/http" |
||||
|
||||
"github.com/getsentry/raven-go" |
||||
"github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
const ( |
||||
fieldEventID = "event_id" |
||||
fieldFingerprint = "fingerprint" |
||||
fieldLogger = "logger" |
||||
fieldServerName = "server_name" |
||||
fieldTags = "tags" |
||||
fieldHTTPRequest = "http_request" |
||||
fieldUser = "user" |
||||
) |
||||
|
||||
type dataField struct { |
||||
data logrus.Fields |
||||
omitList map[string]struct{} |
||||
} |
||||
|
||||
func newDataField(data logrus.Fields) *dataField { |
||||
return &dataField{ |
||||
data: data, |
||||
omitList: make(map[string]struct{}), |
||||
} |
||||
} |
||||
|
||||
func (d *dataField) len() int { |
||||
return len(d.data) |
||||
} |
||||
|
||||
func (d *dataField) isOmit(key string) bool { |
||||
_, ok := d.omitList[key] |
||||
return ok |
||||
} |
||||
|
||||
func (d *dataField) getLogger() (string, bool) { |
||||
if logger, ok := d.data[fieldLogger].(string); ok { |
||||
d.omitList[fieldLogger] = struct{}{} |
||||
return logger, true |
||||
} |
||||
return "", false |
||||
} |
||||
|
||||
func (d *dataField) getServerName() (string, bool) { |
||||
if serverName, ok := d.data[fieldServerName].(string); ok { |
||||
d.omitList[fieldServerName] = struct{}{} |
||||
return serverName, true |
||||
} |
||||
return "", false |
||||
} |
||||
|
||||
func (d *dataField) getTags() (raven.Tags, bool) { |
||||
if tags, ok := d.data[fieldTags].(raven.Tags); ok { |
||||
d.omitList[fieldTags] = struct{}{} |
||||
return tags, true |
||||
} |
||||
return nil, false |
||||
} |
||||
|
||||
func (d *dataField) getFingerprint() ([]string, bool) { |
||||
if fingerprint, ok := d.data[fieldFingerprint].([]string); ok { |
||||
d.omitList[fieldFingerprint] = struct{}{} |
||||
return fingerprint, true |
||||
} |
||||
return nil, false |
||||
} |
||||
|
||||
func (d *dataField) getError() (error, bool) { |
||||
if err, ok := d.data[logrus.ErrorKey].(error); ok { |
||||
d.omitList[logrus.ErrorKey] = struct{}{} |
||||
return err, true |
||||
} |
||||
return nil, false |
||||
} |
||||
|
||||
func (d *dataField) getHTTPRequest() (*raven.Http, bool) { |
||||
if req, ok := d.data[fieldHTTPRequest].(*http.Request); ok { |
||||
d.omitList[fieldHTTPRequest] = struct{}{} |
||||
return raven.NewHttp(req), true |
||||
} |
||||
if req, ok := d.data[fieldHTTPRequest].(*raven.Http); ok { |
||||
d.omitList[fieldHTTPRequest] = struct{}{} |
||||
return req, true |
||||
} |
||||
return nil, false |
||||
} |
||||
|
||||
func (d *dataField) getEventID() (string, bool) { |
||||
eventID, ok := d.data[fieldEventID].(string) |
||||
if !ok { |
||||
return "", false |
||||
} |
||||
|
||||
//verify eventID is 32 characters hexadecimal string (UUID4)
|
||||
uuid := parseUUID(eventID) |
||||
if uuid == nil { |
||||
return "", false |
||||
} |
||||
|
||||
d.omitList[fieldEventID] = struct{}{} |
||||
return uuid.noDashString(), true |
||||
} |
||||
|
||||
func (d *dataField) getUser() (*raven.User, bool) { |
||||
data := d.data |
||||
if v, ok := data[fieldUser]; ok { |
||||
switch val := v.(type) { |
||||
case *raven.User: |
||||
d.omitList[fieldUser] = struct{}{} |
||||
return val, true |
||||
case raven.User: |
||||
d.omitList[fieldUser] = struct{}{} |
||||
return &val, true |
||||
} |
||||
} |
||||
|
||||
username, _ := data["user_name"].(string) |
||||
email, _ := data["user_email"].(string) |
||||
id, _ := data["user_id"].(string) |
||||
ip, _ := data["user_ip"].(string) |
||||
|
||||
if username == "" && email == "" && id == "" && ip == "" { |
||||
return nil, false |
||||
} |
||||
|
||||
return &raven.User{ |
||||
ID: id, |
||||
Username: username, |
||||
Email: email, |
||||
IP: ip, |
||||
}, true |
||||
} |
||||
@ -0,0 +1,424 @@ |
||||
package logrus_sentry |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"fmt" |
||||
"runtime" |
||||
"sync" |
||||
"time" |
||||
|
||||
raven "github.com/getsentry/raven-go" |
||||
"github.com/pkg/errors" |
||||
"github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
var ( |
||||
severityMap = map[logrus.Level]raven.Severity{ |
||||
logrus.TraceLevel: raven.DEBUG, |
||||
logrus.DebugLevel: raven.DEBUG, |
||||
logrus.InfoLevel: raven.INFO, |
||||
logrus.WarnLevel: raven.WARNING, |
||||
logrus.ErrorLevel: raven.ERROR, |
||||
logrus.FatalLevel: raven.FATAL, |
||||
logrus.PanicLevel: raven.FATAL, |
||||
} |
||||
) |
||||
|
||||
// SentryHook delivers logs to a sentry server.
|
||||
type SentryHook struct { |
||||
// Timeout sets the time to wait for a delivery error from the sentry server.
|
||||
// If this is set to zero the server will not wait for any response and will
|
||||
// consider the message correctly sent.
|
||||
//
|
||||
// This is ignored for asynchronous hooks. If you want to set a timeout when
|
||||
// using an async hook (to bound the length of time that hook.Flush can take),
|
||||
// you probably want to create your own raven.Client and set
|
||||
// ravenClient.Transport.(*raven.HTTPTransport).Client.Timeout to set a
|
||||
// timeout on the underlying HTTP request instead.
|
||||
Timeout time.Duration |
||||
StacktraceConfiguration StackTraceConfiguration |
||||
|
||||
client *raven.Client |
||||
levels []logrus.Level |
||||
|
||||
serverName string |
||||
ignoreFields map[string]struct{} |
||||
extraFilters map[string]func(interface{}) interface{} |
||||
errorHandlers []func(entry *logrus.Entry, err error) |
||||
|
||||
asynchronous bool |
||||
|
||||
mu sync.RWMutex |
||||
wg sync.WaitGroup |
||||
} |
||||
|
||||
// The Stacktracer interface allows an error type to return a raven.Stacktrace.
|
||||
type Stacktracer interface { |
||||
GetStacktrace() *raven.Stacktrace |
||||
} |
||||
|
||||
type causer interface { |
||||
Cause() error |
||||
} |
||||
|
||||
type pkgErrorStackTracer interface { |
||||
StackTrace() errors.StackTrace |
||||
} |
||||
|
||||
// StackTraceConfiguration allows for configuring stacktraces
|
||||
type StackTraceConfiguration struct { |
||||
// whether stacktraces should be enabled
|
||||
Enable bool |
||||
// the level at which to start capturing stacktraces
|
||||
Level logrus.Level |
||||
// how many stack frames to skip before stacktrace starts recording
|
||||
Skip int |
||||
// the number of lines to include around a stack frame for context
|
||||
Context int |
||||
// the prefixes that will be matched against the stack frame.
|
||||
// if the stack frame's package matches one of these prefixes
|
||||
// sentry will identify the stack frame as "in_app"
|
||||
InAppPrefixes []string |
||||
// whether sending exception type should be enabled.
|
||||
SendExceptionType bool |
||||
// whether the exception type and message should be switched.
|
||||
SwitchExceptionTypeAndMessage bool |
||||
// whether to include a breadcrumb with the full error stack
|
||||
IncludeErrorBreadcrumb bool |
||||
} |
||||
|
||||
// NewSentryHook creates a hook to be added to an instance of logger
|
||||
// and initializes the raven client.
|
||||
// This method sets the timeout to 100 milliseconds.
|
||||
func NewSentryHook(DSN string, levels []logrus.Level) (*SentryHook, error) { |
||||
client, err := raven.New(DSN) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return NewWithClientSentryHook(client, levels) |
||||
} |
||||
|
||||
// NewWithTagsSentryHook creates a hook with tags to be added to an instance
|
||||
// of logger and initializes the raven client. This method sets the timeout to
|
||||
// 100 milliseconds.
|
||||
func NewWithTagsSentryHook(DSN string, tags map[string]string, levels []logrus.Level) (*SentryHook, error) { |
||||
client, err := raven.NewWithTags(DSN, tags) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return NewWithClientSentryHook(client, levels) |
||||
} |
||||
|
||||
// NewWithClientSentryHook creates a hook using an initialized raven client.
|
||||
// This method sets the timeout to 100 milliseconds.
|
||||
func NewWithClientSentryHook(client *raven.Client, levels []logrus.Level) (*SentryHook, error) { |
||||
return &SentryHook{ |
||||
Timeout: 100 * time.Millisecond, |
||||
StacktraceConfiguration: StackTraceConfiguration{ |
||||
Enable: false, |
||||
Level: logrus.ErrorLevel, |
||||
Skip: 6, |
||||
Context: 0, |
||||
InAppPrefixes: nil, |
||||
SendExceptionType: true, |
||||
}, |
||||
client: client, |
||||
levels: levels, |
||||
ignoreFields: make(map[string]struct{}), |
||||
extraFilters: make(map[string]func(interface{}) interface{}), |
||||
}, nil |
||||
} |
||||
|
||||
// NewAsyncSentryHook creates a hook same as NewSentryHook, but in asynchronous
|
||||
// mode.
|
||||
func NewAsyncSentryHook(DSN string, levels []logrus.Level) (*SentryHook, error) { |
||||
hook, err := NewSentryHook(DSN, levels) |
||||
return setAsync(hook), err |
||||
} |
||||
|
||||
// NewAsyncWithTagsSentryHook creates a hook same as NewWithTagsSentryHook, but
|
||||
// in asynchronous mode.
|
||||
func NewAsyncWithTagsSentryHook(DSN string, tags map[string]string, levels []logrus.Level) (*SentryHook, error) { |
||||
hook, err := NewWithTagsSentryHook(DSN, tags, levels) |
||||
return setAsync(hook), err |
||||
} |
||||
|
||||
// NewAsyncWithClientSentryHook creates a hook same as NewWithClientSentryHook,
|
||||
// but in asynchronous mode.
|
||||
func NewAsyncWithClientSentryHook(client *raven.Client, levels []logrus.Level) (*SentryHook, error) { |
||||
hook, err := NewWithClientSentryHook(client, levels) |
||||
return setAsync(hook), err |
||||
} |
||||
|
||||
func setAsync(hook *SentryHook) *SentryHook { |
||||
if hook == nil { |
||||
return nil |
||||
} |
||||
hook.asynchronous = true |
||||
return hook |
||||
} |
||||
|
||||
// Fire is called when an event should be sent to sentry
|
||||
// Special fields that sentry uses to give more information to the server
|
||||
// are extracted from entry.Data (if they are found)
|
||||
// These fields are: error, logger, server_name, http_request, tags
|
||||
func (hook *SentryHook) Fire(entry *logrus.Entry) error { |
||||
hook.mu.RLock() // Allow multiple go routines to log simultaneously
|
||||
defer hook.mu.RUnlock() |
||||
|
||||
df := newDataField(entry.Data) |
||||
|
||||
err, hasError := df.getError() |
||||
var crumbs *Breadcrumbs |
||||
if hasError && hook.StacktraceConfiguration.IncludeErrorBreadcrumb { |
||||
crumbs = &Breadcrumbs{ |
||||
Values: []Value{{ |
||||
Timestamp: int64(time.Now().Unix()), |
||||
Type: "error", |
||||
Message: fmt.Sprintf("%+v", err), |
||||
}}, |
||||
} |
||||
} |
||||
|
||||
packet := raven.NewPacketWithExtra(entry.Message, nil, crumbs) |
||||
packet.Timestamp = raven.Timestamp(entry.Time) |
||||
packet.Level = severityMap[entry.Level] |
||||
packet.Platform = "go" |
||||
|
||||
// set special fields
|
||||
if hook.serverName != "" { |
||||
packet.ServerName = hook.serverName |
||||
} |
||||
if logger, ok := df.getLogger(); ok { |
||||
packet.Logger = logger |
||||
} |
||||
if serverName, ok := df.getServerName(); ok { |
||||
packet.ServerName = serverName |
||||
} |
||||
if eventID, ok := df.getEventID(); ok { |
||||
packet.EventID = eventID |
||||
} |
||||
if tags, ok := df.getTags(); ok { |
||||
packet.Tags = tags |
||||
} |
||||
if fingerprint, ok := df.getFingerprint(); ok { |
||||
packet.Fingerprint = fingerprint |
||||
} |
||||
if req, ok := df.getHTTPRequest(); ok { |
||||
packet.Interfaces = append(packet.Interfaces, req) |
||||
} |
||||
if user, ok := df.getUser(); ok { |
||||
packet.Interfaces = append(packet.Interfaces, user) |
||||
} |
||||
|
||||
// set stacktrace data
|
||||
stConfig := &hook.StacktraceConfiguration |
||||
if stConfig.Enable && entry.Level <= stConfig.Level { |
||||
if err, ok := df.getError(); ok { |
||||
var currentStacktrace *raven.Stacktrace |
||||
currentStacktrace = hook.findStacktrace(err) |
||||
if currentStacktrace == nil { |
||||
currentStacktrace = raven.NewStacktrace(stConfig.Skip, stConfig.Context, stConfig.InAppPrefixes) |
||||
} |
||||
cause := errors.Cause(err) |
||||
if cause == nil { |
||||
cause = err |
||||
} |
||||
exc := raven.NewException(cause, currentStacktrace) |
||||
if !stConfig.SendExceptionType { |
||||
exc.Type = "" |
||||
} |
||||
if stConfig.SwitchExceptionTypeAndMessage { |
||||
packet.Interfaces = append(packet.Interfaces, currentStacktrace) |
||||
packet.Culprit = exc.Type + ": " + currentStacktrace.Culprit() |
||||
} else { |
||||
packet.Interfaces = append(packet.Interfaces, exc) |
||||
packet.Culprit = err.Error() |
||||
} |
||||
} else { |
||||
currentStacktrace := raven.NewStacktrace(stConfig.Skip, stConfig.Context, stConfig.InAppPrefixes) |
||||
if currentStacktrace != nil { |
||||
packet.Interfaces = append(packet.Interfaces, currentStacktrace) |
||||
} |
||||
} |
||||
} else { |
||||
// set the culprit even when the stack trace is disabled, as long as we have an error
|
||||
if err, ok := df.getError(); ok { |
||||
packet.Culprit = err.Error() |
||||
} |
||||
} |
||||
|
||||
// set other fields
|
||||
dataExtra := hook.formatExtraData(df) |
||||
if packet.Extra == nil { |
||||
packet.Extra = dataExtra |
||||
} else { |
||||
for k, v := range dataExtra { |
||||
packet.Extra[k] = v |
||||
} |
||||
} |
||||
|
||||
_, errCh := hook.client.Capture(packet, nil) |
||||
|
||||
switch { |
||||
case hook.asynchronous: |
||||
// Our use of hook.mu guarantees that we are following the WaitGroup rule of
|
||||
// not calling Add in parallel with Wait.
|
||||
hook.wg.Add(1) |
||||
go func() { |
||||
if err := <-errCh; err != nil { |
||||
for _, handlerFn := range hook.errorHandlers { |
||||
handlerFn(entry, err) |
||||
} |
||||
} |
||||
hook.wg.Done() |
||||
}() |
||||
return nil |
||||
case hook.Timeout == 0: |
||||
return nil |
||||
default: |
||||
timeout := hook.Timeout |
||||
timeoutCh := time.After(timeout) |
||||
select { |
||||
case err := <-errCh: |
||||
for _, handlerFn := range hook.errorHandlers { |
||||
handlerFn(entry, err) |
||||
} |
||||
return err |
||||
case <-timeoutCh: |
||||
return fmt.Errorf("no response from sentry server in %s", timeout) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Flush waits for the log queue to empty. This function only does anything in
|
||||
// asynchronous mode.
|
||||
func (hook *SentryHook) Flush() { |
||||
if !hook.asynchronous { |
||||
return |
||||
} |
||||
hook.mu.Lock() // Claim exclusive access; any logging goroutines will block until the flush completes
|
||||
defer hook.mu.Unlock() |
||||
|
||||
hook.wg.Wait() |
||||
} |
||||
|
||||
func (hook *SentryHook) findStacktrace(err error) *raven.Stacktrace { |
||||
var stacktrace *raven.Stacktrace |
||||
var stackErr errors.StackTrace |
||||
for err != nil { |
||||
// Find the earliest *raven.Stacktrace, or error.StackTrace
|
||||
if tracer, ok := err.(Stacktracer); ok { |
||||
stacktrace = tracer.GetStacktrace() |
||||
stackErr = nil |
||||
} else if tracer, ok := err.(pkgErrorStackTracer); ok { |
||||
stacktrace = nil |
||||
stackErr = tracer.StackTrace() |
||||
} |
||||
if cause, ok := err.(causer); ok { |
||||
err = cause.Cause() |
||||
} else { |
||||
break |
||||
} |
||||
} |
||||
if stackErr != nil { |
||||
stacktrace = hook.convertStackTrace(stackErr) |
||||
} |
||||
return stacktrace |
||||
} |
||||
|
||||
// convertStackTrace converts an errors.StackTrace into a natively consumable
|
||||
// *raven.Stacktrace
|
||||
func (hook *SentryHook) convertStackTrace(st errors.StackTrace) *raven.Stacktrace { |
||||
stConfig := &hook.StacktraceConfiguration |
||||
stFrames := []errors.Frame(st) |
||||
frames := make([]*raven.StacktraceFrame, 0, len(stFrames)) |
||||
for i := range stFrames { |
||||
pc := uintptr(stFrames[i]) |
||||
fn := runtime.FuncForPC(pc) |
||||
file, line := fn.FileLine(pc) |
||||
frame := raven.NewStacktraceFrame(pc, fn.Name(), file, line, stConfig.Context, stConfig.InAppPrefixes) |
||||
if frame != nil { |
||||
frames = append(frames, frame) |
||||
} |
||||
} |
||||
|
||||
// Sentry wants the frames with the oldest first, so reverse them
|
||||
for i, j := 0, len(frames)-1; i < j; i, j = i+1, j-1 { |
||||
frames[i], frames[j] = frames[j], frames[i] |
||||
} |
||||
return &raven.Stacktrace{Frames: frames} |
||||
} |
||||
|
||||
// Levels returns the available logging levels.
|
||||
func (hook *SentryHook) Levels() []logrus.Level { |
||||
return hook.levels |
||||
} |
||||
|
||||
// AddIgnore adds field name to ignore.
|
||||
func (hook *SentryHook) AddIgnore(name string) { |
||||
hook.ignoreFields[name] = struct{}{} |
||||
} |
||||
|
||||
// AddExtraFilter adds a custom filter function.
|
||||
func (hook *SentryHook) AddExtraFilter(name string, fn func(interface{}) interface{}) { |
||||
hook.extraFilters[name] = fn |
||||
} |
||||
|
||||
// AddErrorHandler adds a error handler function used when Sentry returns error.
|
||||
func (hook *SentryHook) AddErrorHandler(fn func(entry *logrus.Entry, err error)) { |
||||
hook.errorHandlers = append(hook.errorHandlers, fn) |
||||
} |
||||
|
||||
func (hook *SentryHook) formatExtraData(df *dataField) (result map[string]interface{}) { |
||||
// create a map for passing to Sentry's extra data
|
||||
result = make(map[string]interface{}, df.len()) |
||||
for k, v := range df.data { |
||||
if df.isOmit(k) { |
||||
continue // skip already used special fields
|
||||
} |
||||
if _, ok := hook.ignoreFields[k]; ok { |
||||
continue |
||||
} |
||||
|
||||
if fn, ok := hook.extraFilters[k]; ok { |
||||
v = fn(v) // apply custom filter
|
||||
} else { |
||||
v = formatData(v) // use default formatter
|
||||
} |
||||
result[k] = v |
||||
} |
||||
return result |
||||
} |
||||
|
||||
// formatData returns value as a suitable format.
|
||||
func formatData(value interface{}) (formatted interface{}) { |
||||
switch value := value.(type) { |
||||
case json.Marshaler: |
||||
return value |
||||
case error: |
||||
return value.Error() |
||||
case fmt.Stringer: |
||||
return value.String() |
||||
default: |
||||
return value |
||||
} |
||||
} |
||||
|
||||
// utility classes for breadcrumb support
|
||||
type Breadcrumbs struct { |
||||
Values []Value `json:"values"` |
||||
} |
||||
|
||||
type Value struct { |
||||
Timestamp int64 `json:"timestamp"` |
||||
Type string `json:"type"` |
||||
Message string `json:"message"` |
||||
Category string `json:"category"` |
||||
Level string `json:"string"` |
||||
Data interface{} `json:"data"` |
||||
} |
||||
|
||||
func (b *Breadcrumbs) Class() string { |
||||
return "breadcrumbs" |
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
package logrus_sentry |
||||
|
||||
import ( |
||||
"github.com/getsentry/raven-go" |
||||
) |
||||
|
||||
// SetDefaultLoggerName sets default logger name tag.
|
||||
func (hook *SentryHook) SetDefaultLoggerName(name string) { |
||||
hook.client.SetDefaultLoggerName(name) |
||||
} |
||||
|
||||
// SetEnvironment sets environment tag.
|
||||
func (hook *SentryHook) SetEnvironment(environment string) { |
||||
hook.client.SetEnvironment(environment) |
||||
} |
||||
|
||||
// SetHttpContext sets http client.
|
||||
func (hook *SentryHook) SetHttpContext(h *raven.Http) { |
||||
hook.client.SetHttpContext(h) |
||||
} |
||||
|
||||
// SetIgnoreErrors sets ignoreErrorsRegexp.
|
||||
func (hook *SentryHook) SetIgnoreErrors(errs ...string) error { |
||||
return hook.client.SetIgnoreErrors(errs) |
||||
} |
||||
|
||||
// SetIncludePaths sets includePaths.
|
||||
func (hook *SentryHook) SetIncludePaths(p []string) { |
||||
hook.client.SetIncludePaths(p) |
||||
} |
||||
|
||||
// SetRelease sets release tag.
|
||||
func (hook *SentryHook) SetRelease(release string) { |
||||
hook.client.SetRelease(release) |
||||
} |
||||
|
||||
// SetSampleRate sets sampling rate.
|
||||
func (hook *SentryHook) SetSampleRate(rate float32) error { |
||||
return hook.client.SetSampleRate(rate) |
||||
} |
||||
|
||||
// SetTagsContext sets tags.
|
||||
func (hook *SentryHook) SetTagsContext(t map[string]string) { |
||||
hook.client.SetTagsContext(t) |
||||
} |
||||
|
||||
// SetUserContext sets user.
|
||||
func (hook *SentryHook) SetUserContext(u *raven.User) { |
||||
hook.client.SetUserContext(u) |
||||
} |
||||
|
||||
// SetServerName sets server_name tag.
|
||||
func (hook *SentryHook) SetServerName(serverName string) { |
||||
hook.serverName = serverName |
||||
} |
||||
@ -0,0 +1,135 @@ |
||||
package logrus_sentry |
||||
|
||||
import ( |
||||
"fmt" |
||||
"strings" |
||||
) |
||||
|
||||
/* |
||||
Copyright (c) 2009,2014 Google Inc. All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Google Inc. nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
|
||||
// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
|
||||
// 4122.
|
||||
type uuid []byte |
||||
|
||||
// parseUUID decodes s into a UUID or returns nil. Both the UUID form of
|
||||
// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
|
||||
// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx and
|
||||
// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded.
|
||||
func parseUUID(s string) uuid { |
||||
//If it is in no dash format "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
|
||||
if len(s) == 32 { |
||||
uuid := make([]byte, 16) |
||||
for i, x := range []int{ |
||||
0, 2, 4, 6, 8, 10, |
||||
12, 14, 16, 18, 20, |
||||
22, 24, 26, 28, 30} { |
||||
if v, ok := xtob(s[x:]); !ok { |
||||
return nil |
||||
} else { |
||||
uuid[i] = v |
||||
} |
||||
} |
||||
return uuid |
||||
} |
||||
|
||||
if len(s) == 36+9 { |
||||
if strings.ToLower(s[:9]) != "urn:uuid:" { |
||||
return nil |
||||
} |
||||
s = s[9:] |
||||
} else if len(s) != 36 { |
||||
return nil |
||||
} |
||||
if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' { |
||||
return nil |
||||
} |
||||
uuid := make([]byte, 16) |
||||
for i, x := range []int{ |
||||
0, 2, 4, 6, |
||||
9, 11, |
||||
14, 16, |
||||
19, 21, |
||||
24, 26, 28, 30, 32, 34} { |
||||
if v, ok := xtob(s[x:]); !ok { |
||||
return nil |
||||
} else { |
||||
uuid[i] = v |
||||
} |
||||
} |
||||
return uuid |
||||
} |
||||
|
||||
// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
// , or "" if uuid is invalid.
|
||||
func (uuid uuid) string() string { |
||||
if uuid == nil || len(uuid) != 16 { |
||||
return "" |
||||
} |
||||
b := []byte(uuid) |
||||
return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", |
||||
b[:4], b[4:6], b[6:8], b[8:10], b[10:]) |
||||
} |
||||
|
||||
func (uuid uuid) noDashString() string { |
||||
if uuid == nil || len(uuid) != 16 { |
||||
return "" |
||||
} |
||||
b := []byte(uuid) |
||||
return fmt.Sprintf("%08x%04x%04x%04x%012x", |
||||
b[:4], b[4:6], b[6:8], b[8:10], b[10:]) |
||||
} |
||||
|
||||
// xvalues returns the value of a byte as a hexadecimal digit or 255.
|
||||
var xvalues = []byte{ |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255, |
||||
255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
} |
||||
|
||||
// xtob converts the the first two hex bytes of x into a byte.
|
||||
func xtob(x string) (byte, bool) { |
||||
b1 := xvalues[x[0]] |
||||
b2 := xvalues[x[1]] |
||||
return (b1 << 4) | b2, b1 != 255 && b2 != 255 |
||||
} |
||||
@ -0,0 +1 @@ |
||||
.git |
||||
@ -0,0 +1,5 @@ |
||||
*.test |
||||
*.out |
||||
example/example |
||||
/xunit.xml |
||||
/coverage.xml |
||||
@ -0,0 +1,41 @@ |
||||
sudo: false |
||||
language: go |
||||
go: |
||||
- 1.7.x |
||||
- 1.8.x |
||||
- 1.9.x |
||||
- 1.10.x |
||||
- 1.11.x |
||||
- tip |
||||
|
||||
before_install: |
||||
- go install -race std |
||||
- go get golang.org/x/tools/cmd/cover |
||||
- go get github.com/tebeka/go2xunit |
||||
- go get github.com/t-yuki/gocover-cobertura |
||||
- go get -v ./... |
||||
|
||||
script: |
||||
- go test -v -race ./... | tee gotest.out |
||||
- $GOPATH/bin/go2xunit -fail -input gotest.out -output xunit.xml |
||||
- go test -v -coverprofile=coverage.txt -covermode count . |
||||
- $GOPATH/bin/gocover-cobertura < coverage.txt > coverage.xml |
||||
|
||||
after_script: |
||||
- npm install -g @zeus-ci/cli |
||||
- zeus upload -t "application/x-cobertura+xml" coverage.xml |
||||
- zeus upload -t "application/x-xunit+xml" xunit.xml |
||||
|
||||
matrix: |
||||
allow_failures: |
||||
- go: tip |
||||
|
||||
notifications: |
||||
webhooks: |
||||
urls: |
||||
- https://zeus.ci/hooks/cd949996-d30a-11e8-ba53-0a580a28042d/public/provider/travis/webhook |
||||
on_success: always |
||||
on_failure: always |
||||
on_start: always |
||||
on_cancel: always |
||||
on_error: always |
||||
@ -0,0 +1,28 @@ |
||||
Copyright (c) 2013 Apollic Software, LLC. All rights reserved. |
||||
Copyright (c) 2015 Functional Software, Inc. All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Apollic Software, LLC nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -0,0 +1,19 @@ |
||||
# raven |
||||
|
||||
[](https://travis-ci.org/getsentry/raven-go) |
||||
[](https://goreportcard.com/report/github.com/getsentry/raven-go) |
||||
[](https://godoc.org/github.com/getsentry/raven-go) |
||||
|
||||
raven is the official Go SDK for the [Sentry](https://github.com/getsentry/sentry) |
||||
event/error logging system. |
||||
|
||||
- [**API Documentation**](https://godoc.org/github.com/getsentry/raven-go) |
||||
- [**Usage and Examples**](https://docs.sentry.io/clients/go/) |
||||
|
||||
## Installation |
||||
|
||||
```text |
||||
go get github.com/getsentry/raven-go |
||||
``` |
||||
|
||||
Note: Go 1.7 and newer are supported. |
||||
@ -0,0 +1,977 @@ |
||||
// Package raven implements a client for the Sentry error logging service.
|
||||
package raven |
||||
|
||||
import ( |
||||
"bytes" |
||||
"compress/zlib" |
||||
"crypto/rand" |
||||
"crypto/tls" |
||||
"encoding/base64" |
||||
"encoding/hex" |
||||
"encoding/json" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"io/ioutil" |
||||
"log" |
||||
mrand "math/rand" |
||||
"net/http" |
||||
"net/url" |
||||
"os" |
||||
"regexp" |
||||
"runtime" |
||||
"strings" |
||||
"sync" |
||||
"time" |
||||
|
||||
"github.com/certifi/gocertifi" |
||||
pkgErrors "github.com/pkg/errors" |
||||
) |
||||
|
||||
const ( |
||||
userAgent = "raven-go/1.0" |
||||
timestampFormat = `"2006-01-02T15:04:05.00"` |
||||
) |
||||
|
||||
var ( |
||||
ErrPacketDropped = errors.New("raven: packet dropped") |
||||
ErrUnableToUnmarshalJSON = errors.New("raven: unable to unmarshal JSON") |
||||
ErrMissingUser = errors.New("raven: dsn missing public key and/or password") |
||||
ErrMissingProjectID = errors.New("raven: dsn missing project id") |
||||
ErrInvalidSampleRate = errors.New("raven: sample rate should be between 0 and 1") |
||||
) |
||||
|
||||
type Severity string |
||||
|
||||
// http://docs.python.org/2/howto/logging.html#logging-levels
|
||||
const ( |
||||
DEBUG = Severity("debug") |
||||
INFO = Severity("info") |
||||
WARNING = Severity("warning") |
||||
ERROR = Severity("error") |
||||
FATAL = Severity("fatal") |
||||
) |
||||
|
||||
type Timestamp time.Time |
||||
|
||||
func (t Timestamp) MarshalJSON() ([]byte, error) { |
||||
return []byte(time.Time(t).UTC().Format(timestampFormat)), nil |
||||
} |
||||
|
||||
func (timestamp *Timestamp) UnmarshalJSON(data []byte) error { |
||||
t, err := time.Parse(timestampFormat, string(data)) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
*timestamp = Timestamp(t) |
||||
return nil |
||||
} |
||||
|
||||
func (timestamp Timestamp) Format(format string) string { |
||||
t := time.Time(timestamp) |
||||
return t.Format(format) |
||||
} |
||||
|
||||
// An Interface is a Sentry interface that will be serialized as JSON.
|
||||
// It must implement json.Marshaler or use json struct tags.
|
||||
type Interface interface { |
||||
// The Sentry class name. Example: sentry.interfaces.Stacktrace
|
||||
Class() string |
||||
} |
||||
|
||||
type Culpriter interface { |
||||
Culprit() string |
||||
} |
||||
|
||||
type Transport interface { |
||||
Send(url, authHeader string, packet *Packet) error |
||||
} |
||||
|
||||
type Extra map[string]interface{} |
||||
|
||||
type outgoingPacket struct { |
||||
packet *Packet |
||||
ch chan error |
||||
} |
||||
|
||||
type Tag struct { |
||||
Key string |
||||
Value string |
||||
} |
||||
|
||||
type Tags []Tag |
||||
|
||||
func (tag *Tag) MarshalJSON() ([]byte, error) { |
||||
return json.Marshal([2]string{tag.Key, tag.Value}) |
||||
} |
||||
|
||||
func (t *Tag) UnmarshalJSON(data []byte) error { |
||||
var tag [2]string |
||||
if err := json.Unmarshal(data, &tag); err != nil { |
||||
return err |
||||
} |
||||
*t = Tag{tag[0], tag[1]} |
||||
return nil |
||||
} |
||||
|
||||
func (t *Tags) UnmarshalJSON(data []byte) error { |
||||
var tags []Tag |
||||
|
||||
switch data[0] { |
||||
case '[': |
||||
// Unmarshal into []Tag
|
||||
if err := json.Unmarshal(data, &tags); err != nil { |
||||
return err |
||||
} |
||||
case '{': |
||||
// Unmarshal into map[string]string
|
||||
tagMap := make(map[string]string) |
||||
if err := json.Unmarshal(data, &tagMap); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Convert to []Tag
|
||||
for k, v := range tagMap { |
||||
tags = append(tags, Tag{k, v}) |
||||
} |
||||
default: |
||||
return ErrUnableToUnmarshalJSON |
||||
} |
||||
|
||||
*t = tags |
||||
return nil |
||||
} |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/#building-the-json-packet
|
||||
type Packet struct { |
||||
// Required
|
||||
Message string `json:"message"` |
||||
|
||||
// Required, set automatically by Client.Send/Report via Packet.Init if blank
|
||||
EventID string `json:"event_id"` |
||||
Project string `json:"project"` |
||||
Timestamp Timestamp `json:"timestamp"` |
||||
Level Severity `json:"level"` |
||||
Logger string `json:"logger"` |
||||
|
||||
// Optional
|
||||
Platform string `json:"platform,omitempty"` |
||||
Culprit string `json:"culprit,omitempty"` |
||||
ServerName string `json:"server_name,omitempty"` |
||||
Release string `json:"release,omitempty"` |
||||
Environment string `json:"environment,omitempty"` |
||||
Tags Tags `json:"tags,omitempty"` |
||||
Modules map[string]string `json:"modules,omitempty"` |
||||
Fingerprint []string `json:"fingerprint,omitempty"` |
||||
Extra Extra `json:"extra,omitempty"` |
||||
|
||||
Interfaces []Interface `json:"-"` |
||||
} |
||||
|
||||
// NewPacket constructs a packet with the specified message and interfaces.
|
||||
func NewPacket(message string, interfaces ...Interface) *Packet { |
||||
extra := Extra{} |
||||
setExtraDefaults(extra) |
||||
return &Packet{ |
||||
Message: message, |
||||
Interfaces: interfaces, |
||||
Extra: extra, |
||||
} |
||||
} |
||||
|
||||
// NewPacketWithExtra constructs a packet with the specified message, extra information, and interfaces.
|
||||
func NewPacketWithExtra(message string, extra Extra, interfaces ...Interface) *Packet { |
||||
if extra == nil { |
||||
extra = Extra{} |
||||
} |
||||
setExtraDefaults(extra) |
||||
|
||||
return &Packet{ |
||||
Message: message, |
||||
Interfaces: interfaces, |
||||
Extra: extra, |
||||
} |
||||
} |
||||
|
||||
func setExtraDefaults(extra Extra) Extra { |
||||
extra["runtime.Version"] = runtime.Version() |
||||
extra["runtime.NumCPU"] = runtime.NumCPU() |
||||
extra["runtime.GOMAXPROCS"] = runtime.GOMAXPROCS(0) // 0 just returns the current value
|
||||
extra["runtime.NumGoroutine"] = runtime.NumGoroutine() |
||||
return extra |
||||
} |
||||
|
||||
// Init initializes required fields in a packet. It is typically called by
|
||||
// Client.Send/Report automatically.
|
||||
func (packet *Packet) Init(project string) error { |
||||
if packet.Project == "" { |
||||
packet.Project = project |
||||
} |
||||
if packet.EventID == "" { |
||||
var err error |
||||
packet.EventID, err = uuid() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if time.Time(packet.Timestamp).IsZero() { |
||||
packet.Timestamp = Timestamp(time.Now()) |
||||
} |
||||
if packet.Level == "" { |
||||
packet.Level = ERROR |
||||
} |
||||
if packet.Logger == "" { |
||||
packet.Logger = "root" |
||||
} |
||||
if packet.ServerName == "" { |
||||
packet.ServerName = hostname |
||||
} |
||||
if packet.Platform == "" { |
||||
packet.Platform = "go" |
||||
} |
||||
|
||||
if packet.Culprit == "" { |
||||
for _, inter := range packet.Interfaces { |
||||
if c, ok := inter.(Culpriter); ok { |
||||
packet.Culprit = c.Culprit() |
||||
if packet.Culprit != "" { |
||||
break |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (packet *Packet) AddTags(tags map[string]string) { |
||||
for k, v := range tags { |
||||
packet.Tags = append(packet.Tags, Tag{k, v}) |
||||
} |
||||
} |
||||
|
||||
func uuid() (string, error) { |
||||
id := make([]byte, 16) |
||||
_, err := io.ReadFull(rand.Reader, id) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
id[6] &= 0x0F // clear version
|
||||
id[6] |= 0x40 // set version to 4 (random uuid)
|
||||
id[8] &= 0x3F // clear variant
|
||||
id[8] |= 0x80 // set to IETF variant
|
||||
return hex.EncodeToString(id), nil |
||||
} |
||||
|
||||
func (packet *Packet) JSON() ([]byte, error) { |
||||
packetJSON, err := json.Marshal(packet) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
interfaces := make(map[string]Interface, len(packet.Interfaces)) |
||||
for _, inter := range packet.Interfaces { |
||||
if inter != nil { |
||||
interfaces[inter.Class()] = inter |
||||
} |
||||
} |
||||
|
||||
if len(interfaces) > 0 { |
||||
interfaceJSON, err := json.Marshal(interfaces) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
packetJSON[len(packetJSON)-1] = ',' |
||||
packetJSON = append(packetJSON, interfaceJSON[1:]...) |
||||
} |
||||
|
||||
return packetJSON, nil |
||||
} |
||||
|
||||
type context struct { |
||||
user *User |
||||
http *Http |
||||
tags map[string]string |
||||
} |
||||
|
||||
func (c *context) setUser(u *User) { c.user = u } |
||||
func (c *context) setHttp(h *Http) { c.http = h } |
||||
func (c *context) setTags(t map[string]string) { |
||||
if c.tags == nil { |
||||
c.tags = make(map[string]string) |
||||
} |
||||
for k, v := range t { |
||||
c.tags[k] = v |
||||
} |
||||
} |
||||
func (c *context) clear() { |
||||
c.user = nil |
||||
c.http = nil |
||||
c.tags = nil |
||||
} |
||||
|
||||
// Return a list of interfaces to be used in appending with the rest
|
||||
func (c *context) interfaces() []Interface { |
||||
len, i := 0, 0 |
||||
if c.user != nil { |
||||
len++ |
||||
} |
||||
if c.http != nil { |
||||
len++ |
||||
} |
||||
interfaces := make([]Interface, len) |
||||
if c.user != nil { |
||||
interfaces[i] = c.user |
||||
i++ |
||||
} |
||||
if c.http != nil { |
||||
interfaces[i] = c.http |
||||
i++ |
||||
} |
||||
return interfaces |
||||
} |
||||
|
||||
// The maximum number of packets that will be buffered waiting to be delivered.
|
||||
// Packets will be dropped if the buffer is full. Used by NewClient.
|
||||
var MaxQueueBuffer = 100 |
||||
|
||||
func newTransport() Transport { |
||||
t := &HTTPTransport{} |
||||
rootCAs, err := gocertifi.CACerts() |
||||
if err != nil { |
||||
log.Println("raven: failed to load root TLS certificates:", err) |
||||
} else { |
||||
t.Client = &http.Client{ |
||||
Transport: &http.Transport{ |
||||
Proxy: http.ProxyFromEnvironment, |
||||
TLSClientConfig: &tls.Config{RootCAs: rootCAs}, |
||||
}, |
||||
} |
||||
} |
||||
return t |
||||
} |
||||
|
||||
func newClient(tags map[string]string) *Client { |
||||
client := &Client{ |
||||
Transport: newTransport(), |
||||
Tags: tags, |
||||
context: &context{}, |
||||
sampleRate: 1.0, |
||||
queue: make(chan *outgoingPacket, MaxQueueBuffer), |
||||
} |
||||
client.SetDSN(os.Getenv("SENTRY_DSN")) |
||||
client.SetRelease(os.Getenv("SENTRY_RELEASE")) |
||||
client.SetEnvironment(os.Getenv("SENTRY_ENVIRONMENT")) |
||||
return client |
||||
} |
||||
|
||||
// New constructs a new Sentry client instance
|
||||
func New(dsn string) (*Client, error) { |
||||
client := newClient(nil) |
||||
return client, client.SetDSN(dsn) |
||||
} |
||||
|
||||
// NewWithTags constructs a new Sentry client instance with default tags.
|
||||
func NewWithTags(dsn string, tags map[string]string) (*Client, error) { |
||||
client := newClient(tags) |
||||
return client, client.SetDSN(dsn) |
||||
} |
||||
|
||||
// NewClient constructs a Sentry client and spawns a background goroutine to
|
||||
// handle packets sent by Client.Report.
|
||||
//
|
||||
// Deprecated: use New and NewWithTags instead
|
||||
func NewClient(dsn string, tags map[string]string) (*Client, error) { |
||||
client := newClient(tags) |
||||
return client, client.SetDSN(dsn) |
||||
} |
||||
|
||||
// Client encapsulates a connection to a Sentry server. It must be initialized
|
||||
// by calling NewClient. Modification of fields concurrently with Send or after
|
||||
// calling Report for the first time is not thread-safe.
|
||||
type Client struct { |
||||
Tags map[string]string |
||||
|
||||
Transport Transport |
||||
|
||||
// DropHandler is called when a packet is dropped because the buffer is full.
|
||||
DropHandler func(*Packet) |
||||
|
||||
// Context that will get appending to all packets
|
||||
context *context |
||||
|
||||
mu sync.RWMutex |
||||
url string |
||||
projectID string |
||||
authHeader string |
||||
release string |
||||
environment string |
||||
sampleRate float32 |
||||
|
||||
// default logger name (leave empty for 'root')
|
||||
defaultLoggerName string |
||||
|
||||
includePaths []string |
||||
ignoreErrorsRegexp *regexp.Regexp |
||||
queue chan *outgoingPacket |
||||
|
||||
// A WaitGroup to keep track of all currently in-progress captures
|
||||
// This is intended to be used with Client.Wait() to assure that
|
||||
// all messages have been transported before exiting the process.
|
||||
wg sync.WaitGroup |
||||
|
||||
// A Once to track only starting up the background worker once
|
||||
start sync.Once |
||||
} |
||||
|
||||
// Initialize a default *Client instance
|
||||
var DefaultClient = newClient(nil) |
||||
|
||||
func (c *Client) SetIgnoreErrors(errs []string) error { |
||||
joinedRegexp := strings.Join(errs, "|") |
||||
r, err := regexp.Compile(joinedRegexp) |
||||
if err != nil { |
||||
return fmt.Errorf("failed to compile regexp %q for %q: %v", joinedRegexp, errs, err) |
||||
} |
||||
|
||||
c.mu.Lock() |
||||
c.ignoreErrorsRegexp = r |
||||
c.mu.Unlock() |
||||
return nil |
||||
} |
||||
|
||||
func (c *Client) shouldExcludeErr(errStr string) bool { |
||||
c.mu.RLock() |
||||
defer c.mu.RUnlock() |
||||
return c.ignoreErrorsRegexp != nil && c.ignoreErrorsRegexp.MatchString(errStr) |
||||
} |
||||
|
||||
func SetIgnoreErrors(errs ...string) error { |
||||
return DefaultClient.SetIgnoreErrors(errs) |
||||
} |
||||
|
||||
// SetDSN updates a client with a new DSN. It safe to call after and
|
||||
// concurrently with calls to Report and Send.
|
||||
func (client *Client) SetDSN(dsn string) error { |
||||
if dsn == "" { |
||||
return nil |
||||
} |
||||
|
||||
client.mu.Lock() |
||||
defer client.mu.Unlock() |
||||
|
||||
uri, err := url.Parse(dsn) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
if uri.User == nil { |
||||
return ErrMissingUser |
||||
} |
||||
publicKey := uri.User.Username() |
||||
secretKey, hasSecretKey := uri.User.Password() |
||||
uri.User = nil |
||||
|
||||
if idx := strings.LastIndex(uri.Path, "/"); idx != -1 { |
||||
client.projectID = uri.Path[idx+1:] |
||||
uri.Path = uri.Path[:idx+1] + "api/" + client.projectID + "/store/" |
||||
} |
||||
if client.projectID == "" { |
||||
return ErrMissingProjectID |
||||
} |
||||
|
||||
client.url = uri.String() |
||||
|
||||
if hasSecretKey { |
||||
client.authHeader = fmt.Sprintf("Sentry sentry_version=4, sentry_key=%s, sentry_secret=%s", publicKey, secretKey) |
||||
} else { |
||||
client.authHeader = fmt.Sprintf("Sentry sentry_version=4, sentry_key=%s", publicKey) |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// Sets the DSN for the default *Client instance
|
||||
func SetDSN(dsn string) error { return DefaultClient.SetDSN(dsn) } |
||||
|
||||
// SetRelease sets the "release" tag.
|
||||
func (client *Client) SetRelease(release string) { |
||||
client.mu.Lock() |
||||
defer client.mu.Unlock() |
||||
client.release = release |
||||
} |
||||
|
||||
// SetEnvironment sets the "environment" tag.
|
||||
func (client *Client) SetEnvironment(environment string) { |
||||
client.mu.Lock() |
||||
defer client.mu.Unlock() |
||||
client.environment = environment |
||||
} |
||||
|
||||
// SetDefaultLoggerName sets the default logger name.
|
||||
func (client *Client) SetDefaultLoggerName(name string) { |
||||
client.mu.Lock() |
||||
defer client.mu.Unlock() |
||||
client.defaultLoggerName = name |
||||
} |
||||
|
||||
// SetSampleRate sets how much sampling we want on client side
|
||||
func (client *Client) SetSampleRate(rate float32) error { |
||||
client.mu.Lock() |
||||
defer client.mu.Unlock() |
||||
|
||||
if rate < 0 || rate > 1 { |
||||
return ErrInvalidSampleRate |
||||
} |
||||
client.sampleRate = rate |
||||
return nil |
||||
} |
||||
|
||||
// SetRelease sets the "release" tag on the default *Client
|
||||
func SetRelease(release string) { DefaultClient.SetRelease(release) } |
||||
|
||||
// SetEnvironment sets the "environment" tag on the default *Client
|
||||
func SetEnvironment(environment string) { DefaultClient.SetEnvironment(environment) } |
||||
|
||||
// SetDefaultLoggerName sets the "defaultLoggerName" on the default *Client
|
||||
func SetDefaultLoggerName(name string) { |
||||
DefaultClient.SetDefaultLoggerName(name) |
||||
} |
||||
|
||||
// SetSampleRate sets the "sample rate" on the degault *Client
|
||||
func SetSampleRate(rate float32) error { return DefaultClient.SetSampleRate(rate) } |
||||
|
||||
func (client *Client) worker() { |
||||
for outgoingPacket := range client.queue { |
||||
|
||||
client.mu.RLock() |
||||
url, authHeader := client.url, client.authHeader |
||||
client.mu.RUnlock() |
||||
|
||||
outgoingPacket.ch <- client.Transport.Send(url, authHeader, outgoingPacket.packet) |
||||
client.wg.Done() |
||||
} |
||||
} |
||||
|
||||
// Capture asynchronously delivers a packet to the Sentry server. It is a no-op
|
||||
// when client is nil. A channel is provided if it is important to check for a
|
||||
// send's success.
|
||||
func (client *Client) Capture(packet *Packet, captureTags map[string]string) (eventID string, ch chan error) { |
||||
ch = make(chan error, 1) |
||||
|
||||
if client == nil { |
||||
// return a chan that always returns nil when the caller receives from it
|
||||
close(ch) |
||||
return |
||||
} |
||||
|
||||
if client.sampleRate < 1.0 && mrand.Float32() > client.sampleRate { |
||||
return |
||||
} |
||||
|
||||
if packet == nil { |
||||
close(ch) |
||||
return |
||||
} |
||||
|
||||
if client.shouldExcludeErr(packet.Message) { |
||||
return |
||||
} |
||||
|
||||
// Keep track of all running Captures so that we can wait for them all to finish
|
||||
// *Must* call client.wg.Done() on any path that indicates that an event was
|
||||
// finished being acted upon, whether success or failure
|
||||
client.wg.Add(1) |
||||
|
||||
// Merge capture tags and client tags
|
||||
packet.AddTags(captureTags) |
||||
packet.AddTags(client.Tags) |
||||
|
||||
// Initialize any required packet fields
|
||||
client.mu.RLock() |
||||
packet.AddTags(client.context.tags) |
||||
projectID := client.projectID |
||||
release := client.release |
||||
environment := client.environment |
||||
defaultLoggerName := client.defaultLoggerName |
||||
client.mu.RUnlock() |
||||
|
||||
// set the global logger name on the packet if we must
|
||||
if packet.Logger == "" && defaultLoggerName != "" { |
||||
packet.Logger = defaultLoggerName |
||||
} |
||||
|
||||
err := packet.Init(projectID) |
||||
if err != nil { |
||||
ch <- err |
||||
client.wg.Done() |
||||
return |
||||
} |
||||
|
||||
if packet.Release == "" { |
||||
packet.Release = release |
||||
} |
||||
|
||||
if packet.Environment == "" { |
||||
packet.Environment = environment |
||||
} |
||||
|
||||
outgoingPacket := &outgoingPacket{packet, ch} |
||||
|
||||
// Lazily start background worker until we
|
||||
// do our first write into the queue.
|
||||
client.start.Do(func() { |
||||
go client.worker() |
||||
}) |
||||
|
||||
select { |
||||
case client.queue <- outgoingPacket: |
||||
default: |
||||
// Send would block, drop the packet
|
||||
if client.DropHandler != nil { |
||||
client.DropHandler(packet) |
||||
} |
||||
ch <- ErrPacketDropped |
||||
client.wg.Done() |
||||
} |
||||
|
||||
return packet.EventID, ch |
||||
} |
||||
|
||||
// Capture asynchronously delivers a packet to the Sentry server with the default *Client.
|
||||
// It is a no-op when client is nil. A channel is provided if it is important to check for a
|
||||
// send's success.
|
||||
func Capture(packet *Packet, captureTags map[string]string) (eventID string, ch chan error) { |
||||
return DefaultClient.Capture(packet, captureTags) |
||||
} |
||||
|
||||
// CaptureMessage formats and delivers a string message to the Sentry server.
|
||||
func (client *Client) CaptureMessage(message string, tags map[string]string, interfaces ...Interface) string { |
||||
if client == nil { |
||||
return "" |
||||
} |
||||
|
||||
if client.shouldExcludeErr(message) { |
||||
return "" |
||||
} |
||||
|
||||
packet := NewPacket(message, append(append(interfaces, client.context.interfaces()...), &Message{message, nil})...) |
||||
eventID, _ := client.Capture(packet, tags) |
||||
|
||||
return eventID |
||||
} |
||||
|
||||
// CaptureMessage formats and delivers a string message to the Sentry server with the default *Client
|
||||
func CaptureMessage(message string, tags map[string]string, interfaces ...Interface) string { |
||||
return DefaultClient.CaptureMessage(message, tags, interfaces...) |
||||
} |
||||
|
||||
// CaptureMessageAndWait is identical to CaptureMessage except it blocks and waits for the message to be sent.
|
||||
func (client *Client) CaptureMessageAndWait(message string, tags map[string]string, interfaces ...Interface) string { |
||||
if client == nil { |
||||
return "" |
||||
} |
||||
|
||||
if client.shouldExcludeErr(message) { |
||||
return "" |
||||
} |
||||
|
||||
packet := NewPacket(message, append(append(interfaces, client.context.interfaces()...), &Message{message, nil})...) |
||||
eventID, ch := client.Capture(packet, tags) |
||||
if eventID != "" { |
||||
<-ch |
||||
} |
||||
|
||||
return eventID |
||||
} |
||||
|
||||
// CaptureMessageAndWait is identical to CaptureMessage except it blocks and waits for the message to be sent.
|
||||
func CaptureMessageAndWait(message string, tags map[string]string, interfaces ...Interface) string { |
||||
return DefaultClient.CaptureMessageAndWait(message, tags, interfaces...) |
||||
} |
||||
|
||||
// CaptureErrors formats and delivers an error to the Sentry server.
|
||||
// Adds a stacktrace to the packet, excluding the call to this method.
|
||||
func (client *Client) CaptureError(err error, tags map[string]string, interfaces ...Interface) string { |
||||
if client == nil { |
||||
return "" |
||||
} |
||||
|
||||
if err == nil { |
||||
return "" |
||||
} |
||||
|
||||
if client.shouldExcludeErr(err.Error()) { |
||||
return "" |
||||
} |
||||
|
||||
extra := extractExtra(err) |
||||
cause := pkgErrors.Cause(err) |
||||
|
||||
packet := NewPacketWithExtra(err.Error(), extra, append(append(interfaces, client.context.interfaces()...), NewException(cause, GetOrNewStacktrace(cause, 1, 3, client.includePaths)))...) |
||||
eventID, _ := client.Capture(packet, tags) |
||||
|
||||
return eventID |
||||
} |
||||
|
||||
// CaptureErrors formats and delivers an error to the Sentry server using the default *Client.
|
||||
// Adds a stacktrace to the packet, excluding the call to this method.
|
||||
func CaptureError(err error, tags map[string]string, interfaces ...Interface) string { |
||||
return DefaultClient.CaptureError(err, tags, interfaces...) |
||||
} |
||||
|
||||
// CaptureErrorAndWait is identical to CaptureError, except it blocks and assures that the event was sent
|
||||
func (client *Client) CaptureErrorAndWait(err error, tags map[string]string, interfaces ...Interface) string { |
||||
if client == nil { |
||||
return "" |
||||
} |
||||
|
||||
if client.shouldExcludeErr(err.Error()) { |
||||
return "" |
||||
} |
||||
|
||||
extra := extractExtra(err) |
||||
cause := pkgErrors.Cause(err) |
||||
|
||||
packet := NewPacketWithExtra(err.Error(), extra, append(append(interfaces, client.context.interfaces()...), NewException(cause, GetOrNewStacktrace(cause, 1, 3, client.includePaths)))...) |
||||
eventID, ch := client.Capture(packet, tags) |
||||
if eventID != "" { |
||||
<-ch |
||||
} |
||||
|
||||
return eventID |
||||
} |
||||
|
||||
// CaptureErrorAndWait is identical to CaptureError, except it blocks and assures that the event was sent
|
||||
func CaptureErrorAndWait(err error, tags map[string]string, interfaces ...Interface) string { |
||||
return DefaultClient.CaptureErrorAndWait(err, tags, interfaces...) |
||||
} |
||||
|
||||
// CapturePanic calls f and then recovers and reports a panic to the Sentry server if it occurs.
|
||||
// If an error is captured, both the error and the reported Sentry error ID are returned.
|
||||
func (client *Client) CapturePanic(f func(), tags map[string]string, interfaces ...Interface) (err interface{}, errorID string) { |
||||
// Note: This doesn't need to check for client, because we still want to go through the defer/recover path
|
||||
// Down the line, Capture will be noop'd, so while this does a _tiny_ bit of overhead constructing the
|
||||
// *Packet just to be thrown away, this should not be the normal case. Could be refactored to
|
||||
// be completely noop though if we cared.
|
||||
defer func() { |
||||
var packet *Packet |
||||
err = recover() |
||||
switch rval := err.(type) { |
||||
case nil: |
||||
return |
||||
case error: |
||||
if client.shouldExcludeErr(rval.Error()) { |
||||
return |
||||
} |
||||
packet = NewPacket(rval.Error(), append(append(interfaces, client.context.interfaces()...), NewException(rval, NewStacktrace(2, 3, client.includePaths)))...) |
||||
default: |
||||
rvalStr := fmt.Sprint(rval) |
||||
if client.shouldExcludeErr(rvalStr) { |
||||
return |
||||
} |
||||
packet = NewPacket(rvalStr, append(append(interfaces, client.context.interfaces()...), NewException(errors.New(rvalStr), NewStacktrace(2, 3, client.includePaths)))...) |
||||
} |
||||
|
||||
errorID, _ = client.Capture(packet, tags) |
||||
}() |
||||
|
||||
f() |
||||
return |
||||
} |
||||
|
||||
// CapturePanic calls f and then recovers and reports a panic to the Sentry server if it occurs.
|
||||
// If an error is captured, both the error and the reported Sentry error ID are returned.
|
||||
func CapturePanic(f func(), tags map[string]string, interfaces ...Interface) (interface{}, string) { |
||||
return DefaultClient.CapturePanic(f, tags, interfaces...) |
||||
} |
||||
|
||||
// CapturePanicAndWait is identical to CaptureError, except it blocks and assures that the event was sent
|
||||
func (client *Client) CapturePanicAndWait(f func(), tags map[string]string, interfaces ...Interface) (err interface{}, errorID string) { |
||||
// Note: This doesn't need to check for client, because we still want to go through the defer/recover path
|
||||
// Down the line, Capture will be noop'd, so while this does a _tiny_ bit of overhead constructing the
|
||||
// *Packet just to be thrown away, this should not be the normal case. Could be refactored to
|
||||
// be completely noop though if we cared.
|
||||
defer func() { |
||||
var packet *Packet |
||||
err = recover() |
||||
switch rval := err.(type) { |
||||
case nil: |
||||
return |
||||
case error: |
||||
if client.shouldExcludeErr(rval.Error()) { |
||||
return |
||||
} |
||||
packet = NewPacket(rval.Error(), append(append(interfaces, client.context.interfaces()...), NewException(rval, NewStacktrace(2, 3, client.includePaths)))...) |
||||
default: |
||||
rvalStr := fmt.Sprint(rval) |
||||
if client.shouldExcludeErr(rvalStr) { |
||||
return |
||||
} |
||||
packet = NewPacket(rvalStr, append(append(interfaces, client.context.interfaces()...), NewException(errors.New(rvalStr), NewStacktrace(2, 3, client.includePaths)))...) |
||||
} |
||||
|
||||
var ch chan error |
||||
errorID, ch = client.Capture(packet, tags) |
||||
if errorID != "" { |
||||
<-ch |
||||
} |
||||
}() |
||||
|
||||
f() |
||||
return |
||||
} |
||||
|
||||
// CapturePanicAndWait is identical to CaptureError, except it blocks and assures that the event was sent
|
||||
func CapturePanicAndWait(f func(), tags map[string]string, interfaces ...Interface) (interface{}, string) { |
||||
return DefaultClient.CapturePanicAndWait(f, tags, interfaces...) |
||||
} |
||||
|
||||
func (client *Client) Close() { |
||||
close(client.queue) |
||||
} |
||||
|
||||
func Close() { DefaultClient.Close() } |
||||
|
||||
// Wait blocks and waits for all events to finish being sent to Sentry server
|
||||
func (client *Client) Wait() { |
||||
client.wg.Wait() |
||||
} |
||||
|
||||
// Wait blocks and waits for all events to finish being sent to Sentry server
|
||||
func Wait() { DefaultClient.Wait() } |
||||
|
||||
func (client *Client) URL() string { |
||||
client.mu.RLock() |
||||
defer client.mu.RUnlock() |
||||
|
||||
return client.url |
||||
} |
||||
|
||||
func URL() string { return DefaultClient.URL() } |
||||
|
||||
func (client *Client) ProjectID() string { |
||||
client.mu.RLock() |
||||
defer client.mu.RUnlock() |
||||
|
||||
return client.projectID |
||||
} |
||||
|
||||
func ProjectID() string { return DefaultClient.ProjectID() } |
||||
|
||||
func (client *Client) Release() string { |
||||
client.mu.RLock() |
||||
defer client.mu.RUnlock() |
||||
|
||||
return client.release |
||||
} |
||||
|
||||
func Release() string { return DefaultClient.Release() } |
||||
|
||||
func IncludePaths() []string { return DefaultClient.IncludePaths() } |
||||
|
||||
func (client *Client) IncludePaths() []string { |
||||
client.mu.RLock() |
||||
defer client.mu.RUnlock() |
||||
|
||||
return client.includePaths |
||||
} |
||||
|
||||
func SetIncludePaths(p []string) { DefaultClient.SetIncludePaths(p) } |
||||
|
||||
func (client *Client) SetIncludePaths(p []string) { |
||||
client.mu.Lock() |
||||
defer client.mu.Unlock() |
||||
|
||||
client.includePaths = p |
||||
} |
||||
|
||||
func (c *Client) SetUserContext(u *User) { |
||||
c.mu.Lock() |
||||
defer c.mu.Unlock() |
||||
c.context.setUser(u) |
||||
} |
||||
|
||||
func (c *Client) SetHttpContext(h *Http) { |
||||
c.mu.Lock() |
||||
defer c.mu.Unlock() |
||||
c.context.setHttp(h) |
||||
} |
||||
|
||||
func (c *Client) SetTagsContext(t map[string]string) { |
||||
c.mu.Lock() |
||||
defer c.mu.Unlock() |
||||
c.context.setTags(t) |
||||
} |
||||
|
||||
func (c *Client) ClearContext() { |
||||
c.mu.Lock() |
||||
defer c.mu.Unlock() |
||||
c.context.clear() |
||||
} |
||||
|
||||
func SetUserContext(u *User) { DefaultClient.SetUserContext(u) } |
||||
func SetHttpContext(h *Http) { DefaultClient.SetHttpContext(h) } |
||||
func SetTagsContext(t map[string]string) { DefaultClient.SetTagsContext(t) } |
||||
func ClearContext() { DefaultClient.ClearContext() } |
||||
|
||||
// HTTPTransport is the default transport, delivering packets to Sentry via the
|
||||
// HTTP API.
|
||||
type HTTPTransport struct { |
||||
*http.Client |
||||
} |
||||
|
||||
func (t *HTTPTransport) Send(url, authHeader string, packet *Packet) error { |
||||
if url == "" { |
||||
return nil |
||||
} |
||||
|
||||
body, contentType, err := serializedPacket(packet) |
||||
if err != nil { |
||||
return fmt.Errorf("error serializing packet: %v", err) |
||||
} |
||||
req, err := http.NewRequest("POST", url, body) |
||||
if err != nil { |
||||
return fmt.Errorf("can't create new request: %v", err) |
||||
} |
||||
req.Header.Set("X-Sentry-Auth", authHeader) |
||||
req.Header.Set("User-Agent", userAgent) |
||||
req.Header.Set("Content-Type", contentType) |
||||
res, err := t.Do(req) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
io.Copy(ioutil.Discard, res.Body) |
||||
res.Body.Close() |
||||
if res.StatusCode != 200 { |
||||
return fmt.Errorf("raven: got http status %d - x-sentry-error: %s", res.StatusCode, res.Header.Get("X-Sentry-Error")) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func serializedPacket(packet *Packet) (io.Reader, string, error) { |
||||
packetJSON, err := packet.JSON() |
||||
if err != nil { |
||||
return nil, "", fmt.Errorf("error marshaling packet %+v to JSON: %v", packet, err) |
||||
} |
||||
|
||||
// Only deflate/base64 the packet if it is bigger than 1KB, as there is
|
||||
// overhead.
|
||||
if len(packetJSON) > 1000 { |
||||
buf := &bytes.Buffer{} |
||||
b64 := base64.NewEncoder(base64.StdEncoding, buf) |
||||
deflate, _ := zlib.NewWriterLevel(b64, zlib.BestCompression) |
||||
deflate.Write(packetJSON) |
||||
deflate.Close() |
||||
b64.Close() |
||||
return buf, "application/octet-stream", nil |
||||
} |
||||
return bytes.NewReader(packetJSON), "application/json", nil |
||||
} |
||||
|
||||
var hostname string |
||||
|
||||
func init() { |
||||
hostname, _ = os.Hostname() |
||||
} |
||||
@ -0,0 +1,60 @@ |
||||
package raven |
||||
|
||||
type causer interface { |
||||
Cause() error |
||||
} |
||||
|
||||
type errWrappedWithExtra struct { |
||||
err error |
||||
extraInfo map[string]interface{} |
||||
} |
||||
|
||||
func (ewx *errWrappedWithExtra) Error() string { |
||||
return ewx.err.Error() |
||||
} |
||||
|
||||
func (ewx *errWrappedWithExtra) Cause() error { |
||||
return ewx.err |
||||
} |
||||
|
||||
func (ewx *errWrappedWithExtra) ExtraInfo() Extra { |
||||
return ewx.extraInfo |
||||
} |
||||
|
||||
// Adds extra data to an error before reporting to Sentry
|
||||
func WrapWithExtra(err error, extraInfo map[string]interface{}) error { |
||||
return &errWrappedWithExtra{ |
||||
err: err, |
||||
extraInfo: extraInfo, |
||||
} |
||||
} |
||||
|
||||
type ErrWithExtra interface { |
||||
Error() string |
||||
Cause() error |
||||
ExtraInfo() Extra |
||||
} |
||||
|
||||
// Iteratively fetches all the Extra data added to an error,
|
||||
// and it's underlying errors. Extra data defined first is
|
||||
// respected, and is not overridden when extracting.
|
||||
func extractExtra(err error) Extra { |
||||
extra := Extra{} |
||||
|
||||
currentErr := err |
||||
for currentErr != nil { |
||||
if errWithExtra, ok := currentErr.(ErrWithExtra); ok { |
||||
for k, v := range errWithExtra.ExtraInfo() { |
||||
extra[k] = v |
||||
} |
||||
} |
||||
|
||||
if errWithCause, ok := currentErr.(causer); ok { |
||||
currentErr = errWithCause.Cause() |
||||
} else { |
||||
currentErr = nil |
||||
} |
||||
} |
||||
|
||||
return extra |
||||
} |
||||
@ -0,0 +1,50 @@ |
||||
package raven |
||||
|
||||
import ( |
||||
"reflect" |
||||
"regexp" |
||||
) |
||||
|
||||
var errorMsgPattern = regexp.MustCompile(`\A(\w+): (.+)\z`) |
||||
|
||||
func NewException(err error, stacktrace *Stacktrace) *Exception { |
||||
msg := err.Error() |
||||
ex := &Exception{ |
||||
Stacktrace: stacktrace, |
||||
Value: msg, |
||||
Type: reflect.TypeOf(err).String(), |
||||
} |
||||
if m := errorMsgPattern.FindStringSubmatch(msg); m != nil { |
||||
ex.Module, ex.Value = m[1], m[2] |
||||
} |
||||
return ex |
||||
} |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/interfaces/#failure-interfaces
|
||||
type Exception struct { |
||||
// Required
|
||||
Value string `json:"value"` |
||||
|
||||
// Optional
|
||||
Type string `json:"type,omitempty"` |
||||
Module string `json:"module,omitempty"` |
||||
Stacktrace *Stacktrace `json:"stacktrace,omitempty"` |
||||
} |
||||
|
||||
func (e *Exception) Class() string { return "exception" } |
||||
|
||||
func (e *Exception) Culprit() string { |
||||
if e.Stacktrace == nil { |
||||
return "" |
||||
} |
||||
return e.Stacktrace.Culprit() |
||||
} |
||||
|
||||
// Exceptions allows for chained errors
|
||||
// https://docs.sentry.io/clientdev/interfaces/exception/
|
||||
type Exceptions struct { |
||||
// Required
|
||||
Values []*Exception `json:"values"` |
||||
} |
||||
|
||||
func (es Exceptions) Class() string { return "exception" } |
||||
@ -0,0 +1,99 @@ |
||||
package raven |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"net" |
||||
"net/http" |
||||
"net/url" |
||||
"runtime/debug" |
||||
"strings" |
||||
) |
||||
|
||||
func NewHttp(req *http.Request) *Http { |
||||
proto := "http" |
||||
if req.TLS != nil || req.Header.Get("X-Forwarded-Proto") == "https" { |
||||
proto = "https" |
||||
} |
||||
h := &Http{ |
||||
Method: req.Method, |
||||
Cookies: req.Header.Get("Cookie"), |
||||
Query: sanitizeQuery(req.URL.Query()).Encode(), |
||||
URL: proto + "://" + req.Host + req.URL.Path, |
||||
Headers: make(map[string]string, len(req.Header)), |
||||
} |
||||
if addr, port, err := net.SplitHostPort(req.RemoteAddr); err == nil { |
||||
h.Env = map[string]string{"REMOTE_ADDR": addr, "REMOTE_PORT": port} |
||||
} |
||||
for k, v := range req.Header { |
||||
h.Headers[k] = strings.Join(v, ",") |
||||
} |
||||
h.Headers["Host"] = req.Host |
||||
return h |
||||
} |
||||
|
||||
var querySecretFields = []string{"password", "passphrase", "passwd", "secret"} |
||||
|
||||
func sanitizeQuery(query url.Values) url.Values { |
||||
for _, keyword := range querySecretFields { |
||||
for field := range query { |
||||
if strings.Contains(field, keyword) { |
||||
query[field] = []string{"********"} |
||||
} |
||||
} |
||||
} |
||||
return query |
||||
} |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/interfaces/#context-interfaces
|
||||
type Http struct { |
||||
// Required
|
||||
URL string `json:"url"` |
||||
Method string `json:"method"` |
||||
Query string `json:"query_string,omitempty"` |
||||
|
||||
// Optional
|
||||
Cookies string `json:"cookies,omitempty"` |
||||
Headers map[string]string `json:"headers,omitempty"` |
||||
Env map[string]string `json:"env,omitempty"` |
||||
|
||||
// Must be either a string or map[string]string
|
||||
Data interface{} `json:"data,omitempty"` |
||||
} |
||||
|
||||
func (h *Http) Class() string { return "request" } |
||||
|
||||
// Recovery handler to wrap the stdlib net/http Mux.
|
||||
// Example:
|
||||
// http.HandleFunc("/", raven.RecoveryHandler(func(w http.ResponseWriter, r *http.Request) {
|
||||
// ...
|
||||
// }))
|
||||
func RecoveryHandler(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) { |
||||
return Recoverer(http.HandlerFunc(handler)).ServeHTTP |
||||
} |
||||
|
||||
// Recovery handler to wrap the stdlib net/http Mux.
|
||||
// Example:
|
||||
// mux := http.NewServeMux
|
||||
// ...
|
||||
// http.Handle("/", raven.Recoverer(mux))
|
||||
func Recoverer(handler http.Handler) http.Handler { |
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
||||
defer func() { |
||||
if rval := recover(); rval != nil { |
||||
debug.PrintStack() |
||||
rvalStr := fmt.Sprint(rval) |
||||
var packet *Packet |
||||
if err, ok := rval.(error); ok { |
||||
packet = NewPacket(rvalStr, NewException(errors.New(rvalStr), GetOrNewStacktrace(err, 2, 3, nil)), NewHttp(r)) |
||||
} else { |
||||
packet = NewPacket(rvalStr, NewException(errors.New(rvalStr), NewStacktrace(2, 3, nil)), NewHttp(r)) |
||||
} |
||||
Capture(packet, nil) |
||||
w.WriteHeader(http.StatusInternalServerError) |
||||
} |
||||
}() |
||||
|
||||
handler.ServeHTTP(w, r) |
||||
}) |
||||
} |
||||
@ -0,0 +1,49 @@ |
||||
package raven |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/interfaces/#message-interface
|
||||
type Message struct { |
||||
// Required
|
||||
Message string `json:"message"` |
||||
|
||||
// Optional
|
||||
Params []interface{} `json:"params,omitempty"` |
||||
} |
||||
|
||||
func (m *Message) Class() string { return "logentry" } |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/interfaces/#template-interface
|
||||
type Template struct { |
||||
// Required
|
||||
Filename string `json:"filename"` |
||||
Lineno int `json:"lineno"` |
||||
ContextLine string `json:"context_line"` |
||||
|
||||
// Optional
|
||||
PreContext []string `json:"pre_context,omitempty"` |
||||
PostContext []string `json:"post_context,omitempty"` |
||||
AbsolutePath string `json:"abs_path,omitempty"` |
||||
} |
||||
|
||||
func (t *Template) Class() string { return "template" } |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/interfaces/#context-interfaces
|
||||
type User struct { |
||||
// All fields are optional
|
||||
ID string `json:"id,omitempty"` |
||||
Username string `json:"username,omitempty"` |
||||
Email string `json:"email,omitempty"` |
||||
IP string `json:"ip_address,omitempty"` |
||||
} |
||||
|
||||
func (h *User) Class() string { return "user" } |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/interfaces/#context-interfaces
|
||||
type Query struct { |
||||
// Required
|
||||
Query string `json:"query"` |
||||
|
||||
// Optional
|
||||
Engine string `json:"engine,omitempty"` |
||||
} |
||||
|
||||
func (q *Query) Class() string { return "query" } |
||||
@ -0,0 +1,4 @@ |
||||
#!/bin/bash |
||||
go test -race ./... |
||||
go test -cover ./... |
||||
go test -v ./... |
||||
@ -0,0 +1,277 @@ |
||||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
// Some code from the runtime/debug package of the Go standard library.
|
||||
|
||||
package raven |
||||
|
||||
import ( |
||||
"bytes" |
||||
"go/build" |
||||
"io/ioutil" |
||||
"path/filepath" |
||||
"runtime" |
||||
"strings" |
||||
"sync" |
||||
|
||||
"github.com/pkg/errors" |
||||
) |
||||
|
||||
// https://docs.getsentry.com/hosted/clientdev/interfaces/#failure-interfaces
|
||||
type Stacktrace struct { |
||||
// Required
|
||||
Frames []*StacktraceFrame `json:"frames"` |
||||
} |
||||
|
||||
func (s *Stacktrace) Class() string { return "stacktrace" } |
||||
|
||||
func (s *Stacktrace) Culprit() string { |
||||
for i := len(s.Frames) - 1; i >= 0; i-- { |
||||
frame := s.Frames[i] |
||||
if frame.InApp == true && frame.Module != "" && frame.Function != "" { |
||||
return frame.Module + "." + frame.Function |
||||
} |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
type StacktraceFrame struct { |
||||
// At least one required
|
||||
Filename string `json:"filename,omitempty"` |
||||
Function string `json:"function,omitempty"` |
||||
Module string `json:"module,omitempty"` |
||||
|
||||
// Optional
|
||||
Lineno int `json:"lineno,omitempty"` |
||||
Colno int `json:"colno,omitempty"` |
||||
AbsolutePath string `json:"abs_path,omitempty"` |
||||
ContextLine string `json:"context_line,omitempty"` |
||||
PreContext []string `json:"pre_context,omitempty"` |
||||
PostContext []string `json:"post_context,omitempty"` |
||||
InApp bool `json:"in_app"` |
||||
} |
||||
|
||||
// Try to get stacktrace from err as an interface of github.com/pkg/errors, or else NewStacktrace()
|
||||
func GetOrNewStacktrace(err error, skip int, context int, appPackagePrefixes []string) *Stacktrace { |
||||
stacktracer, errHasStacktrace := err.(interface { |
||||
StackTrace() errors.StackTrace |
||||
}) |
||||
if errHasStacktrace { |
||||
var frames []*StacktraceFrame |
||||
for _, f := range stacktracer.StackTrace() { |
||||
pc := uintptr(f) - 1 |
||||
fn := runtime.FuncForPC(pc) |
||||
var fName string |
||||
var file string |
||||
var line int |
||||
if fn != nil { |
||||
file, line = fn.FileLine(pc) |
||||
fName = fn.Name() |
||||
} else { |
||||
file = "unknown" |
||||
fName = "unknown" |
||||
} |
||||
frame := NewStacktraceFrame(pc, fName, file, line, context, appPackagePrefixes) |
||||
if frame != nil { |
||||
frames = append([]*StacktraceFrame{frame}, frames...) |
||||
} |
||||
} |
||||
return &Stacktrace{Frames: frames} |
||||
} else { |
||||
return NewStacktrace(skip+1, context, appPackagePrefixes) |
||||
} |
||||
} |
||||
|
||||
// Intialize and populate a new stacktrace, skipping skip frames.
|
||||
//
|
||||
// context is the number of surrounding lines that should be included for context.
|
||||
// Setting context to 3 would try to get seven lines. Setting context to -1 returns
|
||||
// one line with no surrounding context, and 0 returns no context.
|
||||
//
|
||||
// appPackagePrefixes is a list of prefixes used to check whether a package should
|
||||
// be considered "in app".
|
||||
func NewStacktrace(skip int, context int, appPackagePrefixes []string) *Stacktrace { |
||||
var frames []*StacktraceFrame |
||||
|
||||
callerPcs := make([]uintptr, 100) |
||||
numCallers := runtime.Callers(skip+2, callerPcs) |
||||
|
||||
// If there are no callers, the entire stacktrace is nil
|
||||
if numCallers == 0 { |
||||
return nil |
||||
} |
||||
|
||||
callersFrames := runtime.CallersFrames(callerPcs) |
||||
|
||||
for { |
||||
fr, more := callersFrames.Next() |
||||
if fr.Func != nil { |
||||
frame := NewStacktraceFrame(fr.PC, fr.Function, fr.File, fr.Line, context, appPackagePrefixes) |
||||
if frame != nil { |
||||
frames = append(frames, frame) |
||||
} |
||||
} |
||||
if !more { |
||||
break |
||||
} |
||||
} |
||||
// If there are no frames, the entire stacktrace is nil
|
||||
if len(frames) == 0 { |
||||
return nil |
||||
} |
||||
// Optimize the path where there's only 1 frame
|
||||
if len(frames) == 1 { |
||||
return &Stacktrace{frames} |
||||
} |
||||
// Sentry wants the frames with the oldest first, so reverse them
|
||||
for i, j := 0, len(frames)-1; i < j; i, j = i+1, j-1 { |
||||
frames[i], frames[j] = frames[j], frames[i] |
||||
} |
||||
return &Stacktrace{frames} |
||||
} |
||||
|
||||
// Build a single frame using data returned from runtime.Caller.
|
||||
//
|
||||
// context is the number of surrounding lines that should be included for context.
|
||||
// Setting context to 3 would try to get seven lines. Setting context to -1 returns
|
||||
// one line with no surrounding context, and 0 returns no context.
|
||||
//
|
||||
// appPackagePrefixes is a list of prefixes used to check whether a package should
|
||||
// be considered "in app".
|
||||
func NewStacktraceFrame(pc uintptr, fName, file string, line, context int, appPackagePrefixes []string) *StacktraceFrame { |
||||
frame := &StacktraceFrame{AbsolutePath: file, Filename: trimPath(file), Lineno: line, InApp: false} |
||||
frame.Module, frame.Function = functionName(fName) |
||||
|
||||
// `runtime.goexit` is effectively a placeholder that comes from
|
||||
// runtime/asm_amd64.s and is meaningless.
|
||||
if frame.Module == "runtime" && frame.Function == "goexit" { |
||||
return nil |
||||
} |
||||
|
||||
if frame.Module == "main" { |
||||
frame.InApp = true |
||||
} else { |
||||
for _, prefix := range appPackagePrefixes { |
||||
if strings.HasPrefix(frame.Module, prefix) && !strings.Contains(frame.Module, "vendor") && !strings.Contains(frame.Module, "third_party") { |
||||
frame.InApp = true |
||||
} |
||||
} |
||||
} |
||||
|
||||
if context > 0 { |
||||
contextLines, lineIdx := sourceCodeLoader.Load(file, line, context) |
||||
if len(contextLines) > 0 { |
||||
for i, line := range contextLines { |
||||
switch { |
||||
case i < lineIdx: |
||||
frame.PreContext = append(frame.PreContext, string(line)) |
||||
case i == lineIdx: |
||||
frame.ContextLine = string(line) |
||||
default: |
||||
frame.PostContext = append(frame.PostContext, string(line)) |
||||
} |
||||
} |
||||
} |
||||
} else if context == -1 { |
||||
contextLine, _ := sourceCodeLoader.Load(file, line, 0) |
||||
if len(contextLine) > 0 { |
||||
frame.ContextLine = string(contextLine[0]) |
||||
} |
||||
} |
||||
return frame |
||||
} |
||||
|
||||
// Retrieve the name of the package and function containing the PC.
|
||||
func functionName(fName string) (pack string, name string) { |
||||
name = fName |
||||
// We get this:
|
||||
// runtime/debug.*T·ptrmethod
|
||||
// and want this:
|
||||
// pack = runtime/debug
|
||||
// name = *T.ptrmethod
|
||||
if idx := strings.LastIndex(name, "."); idx != -1 { |
||||
pack = name[:idx] |
||||
name = name[idx+1:] |
||||
} |
||||
name = strings.Replace(name, "·", ".", -1) |
||||
return |
||||
} |
||||
|
||||
type SourceCodeLoader interface { |
||||
Load(filename string, line, context int) ([][]byte, int) |
||||
} |
||||
|
||||
var sourceCodeLoader SourceCodeLoader = &fsLoader{cache: make(map[string][][]byte)} |
||||
|
||||
func SetSourceCodeLoader(loader SourceCodeLoader) { |
||||
sourceCodeLoader = loader |
||||
} |
||||
|
||||
type fsLoader struct { |
||||
mu sync.Mutex |
||||
cache map[string][][]byte |
||||
} |
||||
|
||||
func (fs *fsLoader) Load(filename string, line, context int) ([][]byte, int) { |
||||
fs.mu.Lock() |
||||
defer fs.mu.Unlock() |
||||
lines, ok := fs.cache[filename] |
||||
if !ok { |
||||
data, err := ioutil.ReadFile(filename) |
||||
if err != nil { |
||||
// cache errors as nil slice: code below handles it correctly
|
||||
// otherwise when missing the source or running as a different user, we try
|
||||
// reading the file on each error which is unnecessary
|
||||
fs.cache[filename] = nil |
||||
return nil, 0 |
||||
} |
||||
lines = bytes.Split(data, []byte{'\n'}) |
||||
fs.cache[filename] = lines |
||||
} |
||||
|
||||
if lines == nil { |
||||
// cached error from ReadFile: return no lines
|
||||
return nil, 0 |
||||
} |
||||
|
||||
line-- // stack trace lines are 1-indexed
|
||||
start := line - context |
||||
var idx int |
||||
if start < 0 { |
||||
start = 0 |
||||
idx = line |
||||
} else { |
||||
idx = context |
||||
} |
||||
end := line + context + 1 |
||||
if line >= len(lines) { |
||||
return nil, 0 |
||||
} |
||||
if end > len(lines) { |
||||
end = len(lines) |
||||
} |
||||
return lines[start:end], idx |
||||
} |
||||
|
||||
var trimPaths []string |
||||
|
||||
// Try to trim the GOROOT or GOPATH prefix off of a filename
|
||||
func trimPath(filename string) string { |
||||
for _, prefix := range trimPaths { |
||||
if trimmed := strings.TrimPrefix(filename, prefix); len(trimmed) < len(filename) { |
||||
return trimmed |
||||
} |
||||
} |
||||
return filename |
||||
} |
||||
|
||||
func init() { |
||||
// Collect all source directories, and make sure they
|
||||
// end in a trailing "separator"
|
||||
for _, prefix := range build.Default.SrcDirs() { |
||||
if prefix[len(prefix)-1] != filepath.Separator { |
||||
prefix += string(filepath.Separator) |
||||
} |
||||
trimPaths = append(trimPaths, prefix) |
||||
} |
||||
} |
||||
@ -0,0 +1,20 @@ |
||||
package raven |
||||
|
||||
type Writer struct { |
||||
Client *Client |
||||
Level Severity |
||||
Logger string // Logger name reported to Sentry
|
||||
} |
||||
|
||||
// Write formats the byte slice p into a string, and sends a message to
|
||||
// Sentry at the severity level indicated by the Writer w.
|
||||
func (w *Writer) Write(p []byte) (int, error) { |
||||
message := string(p) |
||||
|
||||
packet := NewPacket(message, &Message{message, nil}) |
||||
packet.Level = w.Level |
||||
packet.Logger = w.Logger |
||||
w.Client.Capture(packet, nil) |
||||
|
||||
return len(p), nil |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
# Compiled Object files, Static and Dynamic libs (Shared Objects) |
||||
*.o |
||||
*.a |
||||
*.so |
||||
|
||||
# Folders |
||||
_obj |
||||
_test |
||||
|
||||
# Architecture specific extensions/prefixes |
||||
*.[568vq] |
||||
[568vq].out |
||||
|
||||
*.cgo1.go |
||||
*.cgo2.c |
||||
_cgo_defun.c |
||||
_cgo_gotypes.go |
||||
_cgo_export.* |
||||
|
||||
_testmain.go |
||||
|
||||
*.exe |
||||
*.test |
||||
*.prof |
||||
@ -0,0 +1,10 @@ |
||||
language: go |
||||
go_import_path: github.com/pkg/errors |
||||
go: |
||||
- 1.11.x |
||||
- 1.12.x |
||||
- 1.13.x |
||||
- tip |
||||
|
||||
script: |
||||
- make check |
||||
@ -0,0 +1,23 @@ |
||||
Copyright (c) 2015, Dave Cheney <dave@cheney.net> |
||||
All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are met: |
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this |
||||
list of conditions and the following disclaimer. |
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice, |
||||
this list of conditions and the following disclaimer in the documentation |
||||
and/or other materials provided with the distribution. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
||||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
||||
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -0,0 +1,44 @@ |
||||
PKGS := github.com/pkg/errors
|
||||
SRCDIRS := $(shell go list -f '{{.Dir}}' $(PKGS))
|
||||
GO := go
|
||||
|
||||
check: test vet gofmt misspell unconvert staticcheck ineffassign unparam |
||||
|
||||
test: |
||||
$(GO) test $(PKGS)
|
||||
|
||||
vet: | test |
||||
$(GO) vet $(PKGS)
|
||||
|
||||
staticcheck: |
||||
$(GO) get honnef.co/go/tools/cmd/staticcheck
|
||||
staticcheck -checks all $(PKGS)
|
||||
|
||||
misspell: |
||||
$(GO) get github.com/client9/misspell/cmd/misspell
|
||||
misspell \
|
||||
-locale GB \
|
||||
-error \
|
||||
*.md *.go
|
||||
|
||||
unconvert: |
||||
$(GO) get github.com/mdempsky/unconvert
|
||||
unconvert -v $(PKGS)
|
||||
|
||||
ineffassign: |
||||
$(GO) get github.com/gordonklaus/ineffassign
|
||||
find $(SRCDIRS) -name '*.go' | xargs ineffassign
|
||||
|
||||
pedantic: check errcheck |
||||
|
||||
unparam: |
||||
$(GO) get mvdan.cc/unparam
|
||||
unparam ./...
|
||||
|
||||
errcheck: |
||||
$(GO) get github.com/kisielk/errcheck
|
||||
errcheck $(PKGS)
|
||||
|
||||
gofmt: |
||||
@echo Checking code is gofmted
|
||||
@test -z "$(shell gofmt -s -l -d -e $(SRCDIRS) | tee /dev/stderr)"
|
||||
@ -0,0 +1,59 @@ |
||||
# errors [](https://travis-ci.org/pkg/errors) [](https://ci.appveyor.com/project/davecheney/errors/branch/master) [](http://godoc.org/github.com/pkg/errors) [](https://goreportcard.com/report/github.com/pkg/errors) [](https://sourcegraph.com/github.com/pkg/errors?badge) |
||||
|
||||
Package errors provides simple error handling primitives. |
||||
|
||||
`go get github.com/pkg/errors` |
||||
|
||||
The traditional error handling idiom in Go is roughly akin to |
||||
```go |
||||
if err != nil { |
||||
return err |
||||
} |
||||
``` |
||||
which applied recursively up the call stack results in error reports without context or debugging information. The errors package allows programmers to add context to the failure path in their code in a way that does not destroy the original value of the error. |
||||
|
||||
## Adding context to an error |
||||
|
||||
The errors.Wrap function returns a new error that adds context to the original error. For example |
||||
```go |
||||
_, err := ioutil.ReadAll(r) |
||||
if err != nil { |
||||
return errors.Wrap(err, "read failed") |
||||
} |
||||
``` |
||||
## Retrieving the cause of an error |
||||
|
||||
Using `errors.Wrap` constructs a stack of errors, adding context to the preceding error. Depending on the nature of the error it may be necessary to reverse the operation of errors.Wrap to retrieve the original error for inspection. Any error value which implements this interface can be inspected by `errors.Cause`. |
||||
```go |
||||
type causer interface { |
||||
Cause() error |
||||
} |
||||
``` |
||||
`errors.Cause` will recursively retrieve the topmost error which does not implement `causer`, which is assumed to be the original cause. For example: |
||||
```go |
||||
switch err := errors.Cause(err).(type) { |
||||
case *MyError: |
||||
// handle specifically |
||||
default: |
||||
// unknown error |
||||
} |
||||
``` |
||||
|
||||
[Read the package documentation for more information](https://godoc.org/github.com/pkg/errors). |
||||
|
||||
## Roadmap |
||||
|
||||
With the upcoming [Go2 error proposals](https://go.googlesource.com/proposal/+/master/design/go2draft.md) this package is moving into maintenance mode. The roadmap for a 1.0 release is as follows: |
||||
|
||||
- 0.9. Remove pre Go 1.9 and Go 1.10 support, address outstanding pull requests (if possible) |
||||
- 1.0. Final release. |
||||
|
||||
## Contributing |
||||
|
||||
Because of the Go2 errors changes, this package is not accepting proposals for new functionality. With that said, we welcome pull requests, bug fixes and issue reports. |
||||
|
||||
Before sending a PR, please discuss your change by raising an issue. |
||||
|
||||
## License |
||||
|
||||
BSD-2-Clause |
||||
@ -0,0 +1,32 @@ |
||||
version: build-{build}.{branch} |
||||
|
||||
clone_folder: C:\gopath\src\github.com\pkg\errors |
||||
shallow_clone: true # for startup speed |
||||
|
||||
environment: |
||||
GOPATH: C:\gopath |
||||
|
||||
platform: |
||||
- x64 |
||||
|
||||
# http://www.appveyor.com/docs/installed-software |
||||
install: |
||||
# some helpful output for debugging builds |
||||
- go version |
||||
- go env |
||||
# pre-installed MinGW at C:\MinGW is 32bit only |
||||
# but MSYS2 at C:\msys64 has mingw64 |
||||
- set PATH=C:\msys64\mingw64\bin;%PATH% |
||||
- gcc --version |
||||
- g++ --version |
||||
|
||||
build_script: |
||||
- go install -v ./... |
||||
|
||||
test_script: |
||||
- set PATH=C:\gopath\bin;%PATH% |
||||
- go test -v ./... |
||||
|
||||
#artifacts: |
||||
# - path: '%GOPATH%\bin\*.exe' |
||||
deploy: off |
||||
@ -0,0 +1,288 @@ |
||||
// Package errors provides simple error handling primitives.
|
||||
//
|
||||
// The traditional error handling idiom in Go is roughly akin to
|
||||
//
|
||||
// if err != nil {
|
||||
// return err
|
||||
// }
|
||||
//
|
||||
// which when applied recursively up the call stack results in error reports
|
||||
// without context or debugging information. The errors package allows
|
||||
// programmers to add context to the failure path in their code in a way
|
||||
// that does not destroy the original value of the error.
|
||||
//
|
||||
// Adding context to an error
|
||||
//
|
||||
// The errors.Wrap function returns a new error that adds context to the
|
||||
// original error by recording a stack trace at the point Wrap is called,
|
||||
// together with the supplied message. For example
|
||||
//
|
||||
// _, err := ioutil.ReadAll(r)
|
||||
// if err != nil {
|
||||
// return errors.Wrap(err, "read failed")
|
||||
// }
|
||||
//
|
||||
// If additional control is required, the errors.WithStack and
|
||||
// errors.WithMessage functions destructure errors.Wrap into its component
|
||||
// operations: annotating an error with a stack trace and with a message,
|
||||
// respectively.
|
||||
//
|
||||
// Retrieving the cause of an error
|
||||
//
|
||||
// Using errors.Wrap constructs a stack of errors, adding context to the
|
||||
// preceding error. Depending on the nature of the error it may be necessary
|
||||
// to reverse the operation of errors.Wrap to retrieve the original error
|
||||
// for inspection. Any error value which implements this interface
|
||||
//
|
||||
// type causer interface {
|
||||
// Cause() error
|
||||
// }
|
||||
//
|
||||
// can be inspected by errors.Cause. errors.Cause will recursively retrieve
|
||||
// the topmost error that does not implement causer, which is assumed to be
|
||||
// the original cause. For example:
|
||||
//
|
||||
// switch err := errors.Cause(err).(type) {
|
||||
// case *MyError:
|
||||
// // handle specifically
|
||||
// default:
|
||||
// // unknown error
|
||||
// }
|
||||
//
|
||||
// Although the causer interface is not exported by this package, it is
|
||||
// considered a part of its stable public interface.
|
||||
//
|
||||
// Formatted printing of errors
|
||||
//
|
||||
// All error values returned from this package implement fmt.Formatter and can
|
||||
// be formatted by the fmt package. The following verbs are supported:
|
||||
//
|
||||
// %s print the error. If the error has a Cause it will be
|
||||
// printed recursively.
|
||||
// %v see %s
|
||||
// %+v extended format. Each Frame of the error's StackTrace will
|
||||
// be printed in detail.
|
||||
//
|
||||
// Retrieving the stack trace of an error or wrapper
|
||||
//
|
||||
// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
|
||||
// invoked. This information can be retrieved with the following interface:
|
||||
//
|
||||
// type stackTracer interface {
|
||||
// StackTrace() errors.StackTrace
|
||||
// }
|
||||
//
|
||||
// The returned errors.StackTrace type is defined as
|
||||
//
|
||||
// type StackTrace []Frame
|
||||
//
|
||||
// The Frame type represents a call site in the stack trace. Frame supports
|
||||
// the fmt.Formatter interface that can be used for printing information about
|
||||
// the stack trace of this error. For example:
|
||||
//
|
||||
// if err, ok := err.(stackTracer); ok {
|
||||
// for _, f := range err.StackTrace() {
|
||||
// fmt.Printf("%+s:%d\n", f, f)
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// Although the stackTracer interface is not exported by this package, it is
|
||||
// considered a part of its stable public interface.
|
||||
//
|
||||
// See the documentation for Frame.Format for more details.
|
||||
package errors |
||||
|
||||
import ( |
||||
"fmt" |
||||
"io" |
||||
) |
||||
|
||||
// New returns an error with the supplied message.
|
||||
// New also records the stack trace at the point it was called.
|
||||
func New(message string) error { |
||||
return &fundamental{ |
||||
msg: message, |
||||
stack: callers(), |
||||
} |
||||
} |
||||
|
||||
// Errorf formats according to a format specifier and returns the string
|
||||
// as a value that satisfies error.
|
||||
// Errorf also records the stack trace at the point it was called.
|
||||
func Errorf(format string, args ...interface{}) error { |
||||
return &fundamental{ |
||||
msg: fmt.Sprintf(format, args...), |
||||
stack: callers(), |
||||
} |
||||
} |
||||
|
||||
// fundamental is an error that has a message and a stack, but no caller.
|
||||
type fundamental struct { |
||||
msg string |
||||
*stack |
||||
} |
||||
|
||||
func (f *fundamental) Error() string { return f.msg } |
||||
|
||||
func (f *fundamental) Format(s fmt.State, verb rune) { |
||||
switch verb { |
||||
case 'v': |
||||
if s.Flag('+') { |
||||
io.WriteString(s, f.msg) |
||||
f.stack.Format(s, verb) |
||||
return |
||||
} |
||||
fallthrough |
||||
case 's': |
||||
io.WriteString(s, f.msg) |
||||
case 'q': |
||||
fmt.Fprintf(s, "%q", f.msg) |
||||
} |
||||
} |
||||
|
||||
// WithStack annotates err with a stack trace at the point WithStack was called.
|
||||
// If err is nil, WithStack returns nil.
|
||||
func WithStack(err error) error { |
||||
if err == nil { |
||||
return nil |
||||
} |
||||
return &withStack{ |
||||
err, |
||||
callers(), |
||||
} |
||||
} |
||||
|
||||
type withStack struct { |
||||
error |
||||
*stack |
||||
} |
||||
|
||||
func (w *withStack) Cause() error { return w.error } |
||||
|
||||
// Unwrap provides compatibility for Go 1.13 error chains.
|
||||
func (w *withStack) Unwrap() error { return w.error } |
||||
|
||||
func (w *withStack) Format(s fmt.State, verb rune) { |
||||
switch verb { |
||||
case 'v': |
||||
if s.Flag('+') { |
||||
fmt.Fprintf(s, "%+v", w.Cause()) |
||||
w.stack.Format(s, verb) |
||||
return |
||||
} |
||||
fallthrough |
||||
case 's': |
||||
io.WriteString(s, w.Error()) |
||||
case 'q': |
||||
fmt.Fprintf(s, "%q", w.Error()) |
||||
} |
||||
} |
||||
|
||||
// Wrap returns an error annotating err with a stack trace
|
||||
// at the point Wrap is called, and the supplied message.
|
||||
// If err is nil, Wrap returns nil.
|
||||
func Wrap(err error, message string) error { |
||||
if err == nil { |
||||
return nil |
||||
} |
||||
err = &withMessage{ |
||||
cause: err, |
||||
msg: message, |
||||
} |
||||
return &withStack{ |
||||
err, |
||||
callers(), |
||||
} |
||||
} |
||||
|
||||
// Wrapf returns an error annotating err with a stack trace
|
||||
// at the point Wrapf is called, and the format specifier.
|
||||
// If err is nil, Wrapf returns nil.
|
||||
func Wrapf(err error, format string, args ...interface{}) error { |
||||
if err == nil { |
||||
return nil |
||||
} |
||||
err = &withMessage{ |
||||
cause: err, |
||||
msg: fmt.Sprintf(format, args...), |
||||
} |
||||
return &withStack{ |
||||
err, |
||||
callers(), |
||||
} |
||||
} |
||||
|
||||
// WithMessage annotates err with a new message.
|
||||
// If err is nil, WithMessage returns nil.
|
||||
func WithMessage(err error, message string) error { |
||||
if err == nil { |
||||
return nil |
||||
} |
||||
return &withMessage{ |
||||
cause: err, |
||||
msg: message, |
||||
} |
||||
} |
||||
|
||||
// WithMessagef annotates err with the format specifier.
|
||||
// If err is nil, WithMessagef returns nil.
|
||||
func WithMessagef(err error, format string, args ...interface{}) error { |
||||
if err == nil { |
||||
return nil |
||||
} |
||||
return &withMessage{ |
||||
cause: err, |
||||
msg: fmt.Sprintf(format, args...), |
||||
} |
||||
} |
||||
|
||||
type withMessage struct { |
||||
cause error |
||||
msg string |
||||
} |
||||
|
||||
func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() } |
||||
func (w *withMessage) Cause() error { return w.cause } |
||||
|
||||
// Unwrap provides compatibility for Go 1.13 error chains.
|
||||
func (w *withMessage) Unwrap() error { return w.cause } |
||||
|
||||
func (w *withMessage) Format(s fmt.State, verb rune) { |
||||
switch verb { |
||||
case 'v': |
||||
if s.Flag('+') { |
||||
fmt.Fprintf(s, "%+v\n", w.Cause()) |
||||
io.WriteString(s, w.msg) |
||||
return |
||||
} |
||||
fallthrough |
||||
case 's', 'q': |
||||
io.WriteString(s, w.Error()) |
||||
} |
||||
} |
||||
|
||||
// Cause returns the underlying cause of the error, if possible.
|
||||
// An error value has a cause if it implements the following
|
||||
// interface:
|
||||
//
|
||||
// type causer interface {
|
||||
// Cause() error
|
||||
// }
|
||||
//
|
||||
// If the error does not implement Cause, the original error will
|
||||
// be returned. If the error is nil, nil will be returned without further
|
||||
// investigation.
|
||||
func Cause(err error) error { |
||||
type causer interface { |
||||
Cause() error |
||||
} |
||||
|
||||
for err != nil { |
||||
cause, ok := err.(causer) |
||||
if !ok { |
||||
break |
||||
} |
||||
err = cause.Cause() |
||||
} |
||||
return err |
||||
} |
||||
@ -0,0 +1,38 @@ |
||||
// +build go1.13
|
||||
|
||||
package errors |
||||
|
||||
import ( |
||||
stderrors "errors" |
||||
) |
||||
|
||||
// Is reports whether any error in err's chain matches target.
|
||||
//
|
||||
// The chain consists of err itself followed by the sequence of errors obtained by
|
||||
// repeatedly calling Unwrap.
|
||||
//
|
||||
// An error is considered to match a target if it is equal to that target or if
|
||||
// it implements a method Is(error) bool such that Is(target) returns true.
|
||||
func Is(err, target error) bool { return stderrors.Is(err, target) } |
||||
|
||||
// As finds the first error in err's chain that matches target, and if so, sets
|
||||
// target to that error value and returns true.
|
||||
//
|
||||
// The chain consists of err itself followed by the sequence of errors obtained by
|
||||
// repeatedly calling Unwrap.
|
||||
//
|
||||
// An error matches target if the error's concrete value is assignable to the value
|
||||
// pointed to by target, or if the error has a method As(interface{}) bool such that
|
||||
// As(target) returns true. In the latter case, the As method is responsible for
|
||||
// setting target.
|
||||
//
|
||||
// As will panic if target is not a non-nil pointer to either a type that implements
|
||||
// error, or to any interface type. As returns false if err is nil.
|
||||
func As(err error, target interface{}) bool { return stderrors.As(err, target) } |
||||
|
||||
// Unwrap returns the result of calling the Unwrap method on err, if err's
|
||||
// type contains an Unwrap method returning error.
|
||||
// Otherwise, Unwrap returns nil.
|
||||
func Unwrap(err error) error { |
||||
return stderrors.Unwrap(err) |
||||
} |
||||
@ -0,0 +1,177 @@ |
||||
package errors |
||||
|
||||
import ( |
||||
"fmt" |
||||
"io" |
||||
"path" |
||||
"runtime" |
||||
"strconv" |
||||
"strings" |
||||
) |
||||
|
||||
// Frame represents a program counter inside a stack frame.
|
||||
// For historical reasons if Frame is interpreted as a uintptr
|
||||
// its value represents the program counter + 1.
|
||||
type Frame uintptr |
||||
|
||||
// pc returns the program counter for this frame;
|
||||
// multiple frames may have the same PC value.
|
||||
func (f Frame) pc() uintptr { return uintptr(f) - 1 } |
||||
|
||||
// file returns the full path to the file that contains the
|
||||
// function for this Frame's pc.
|
||||
func (f Frame) file() string { |
||||
fn := runtime.FuncForPC(f.pc()) |
||||
if fn == nil { |
||||
return "unknown" |
||||
} |
||||
file, _ := fn.FileLine(f.pc()) |
||||
return file |
||||
} |
||||
|
||||
// line returns the line number of source code of the
|
||||
// function for this Frame's pc.
|
||||
func (f Frame) line() int { |
||||
fn := runtime.FuncForPC(f.pc()) |
||||
if fn == nil { |
||||
return 0 |
||||
} |
||||
_, line := fn.FileLine(f.pc()) |
||||
return line |
||||
} |
||||
|
||||
// name returns the name of this function, if known.
|
||||
func (f Frame) name() string { |
||||
fn := runtime.FuncForPC(f.pc()) |
||||
if fn == nil { |
||||
return "unknown" |
||||
} |
||||
return fn.Name() |
||||
} |
||||
|
||||
// Format formats the frame according to the fmt.Formatter interface.
|
||||
//
|
||||
// %s source file
|
||||
// %d source line
|
||||
// %n function name
|
||||
// %v equivalent to %s:%d
|
||||
//
|
||||
// Format accepts flags that alter the printing of some verbs, as follows:
|
||||
//
|
||||
// %+s function name and path of source file relative to the compile time
|
||||
// GOPATH separated by \n\t (<funcname>\n\t<path>)
|
||||
// %+v equivalent to %+s:%d
|
||||
func (f Frame) Format(s fmt.State, verb rune) { |
||||
switch verb { |
||||
case 's': |
||||
switch { |
||||
case s.Flag('+'): |
||||
io.WriteString(s, f.name()) |
||||
io.WriteString(s, "\n\t") |
||||
io.WriteString(s, f.file()) |
||||
default: |
||||
io.WriteString(s, path.Base(f.file())) |
||||
} |
||||
case 'd': |
||||
io.WriteString(s, strconv.Itoa(f.line())) |
||||
case 'n': |
||||
io.WriteString(s, funcname(f.name())) |
||||
case 'v': |
||||
f.Format(s, 's') |
||||
io.WriteString(s, ":") |
||||
f.Format(s, 'd') |
||||
} |
||||
} |
||||
|
||||
// MarshalText formats a stacktrace Frame as a text string. The output is the
|
||||
// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
|
||||
func (f Frame) MarshalText() ([]byte, error) { |
||||
name := f.name() |
||||
if name == "unknown" { |
||||
return []byte(name), nil |
||||
} |
||||
return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil |
||||
} |
||||
|
||||
// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
|
||||
type StackTrace []Frame |
||||
|
||||
// Format formats the stack of Frames according to the fmt.Formatter interface.
|
||||
//
|
||||
// %s lists source files for each Frame in the stack
|
||||
// %v lists the source file and line number for each Frame in the stack
|
||||
//
|
||||
// Format accepts flags that alter the printing of some verbs, as follows:
|
||||
//
|
||||
// %+v Prints filename, function, and line number for each Frame in the stack.
|
||||
func (st StackTrace) Format(s fmt.State, verb rune) { |
||||
switch verb { |
||||
case 'v': |
||||
switch { |
||||
case s.Flag('+'): |
||||
for _, f := range st { |
||||
io.WriteString(s, "\n") |
||||
f.Format(s, verb) |
||||
} |
||||
case s.Flag('#'): |
||||
fmt.Fprintf(s, "%#v", []Frame(st)) |
||||
default: |
||||
st.formatSlice(s, verb) |
||||
} |
||||
case 's': |
||||
st.formatSlice(s, verb) |
||||
} |
||||
} |
||||
|
||||
// formatSlice will format this StackTrace into the given buffer as a slice of
|
||||
// Frame, only valid when called with '%s' or '%v'.
|
||||
func (st StackTrace) formatSlice(s fmt.State, verb rune) { |
||||
io.WriteString(s, "[") |
||||
for i, f := range st { |
||||
if i > 0 { |
||||
io.WriteString(s, " ") |
||||
} |
||||
f.Format(s, verb) |
||||
} |
||||
io.WriteString(s, "]") |
||||
} |
||||
|
||||
// stack represents a stack of program counters.
|
||||
type stack []uintptr |
||||
|
||||
func (s *stack) Format(st fmt.State, verb rune) { |
||||
switch verb { |
||||
case 'v': |
||||
switch { |
||||
case st.Flag('+'): |
||||
for _, pc := range *s { |
||||
f := Frame(pc) |
||||
fmt.Fprintf(st, "\n%+v", f) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (s *stack) StackTrace() StackTrace { |
||||
f := make([]Frame, len(*s)) |
||||
for i := 0; i < len(f); i++ { |
||||
f[i] = Frame((*s)[i]) |
||||
} |
||||
return f |
||||
} |
||||
|
||||
func callers() *stack { |
||||
const depth = 32 |
||||
var pcs [depth]uintptr |
||||
n := runtime.Callers(3, pcs[:]) |
||||
var st stack = pcs[0:n] |
||||
return &st |
||||
} |
||||
|
||||
// funcname removes the path prefix component of a function's name reported by func.Name().
|
||||
func funcname(name string) string { |
||||
i := strings.LastIndex(name, "/") |
||||
name = name[i+1:] |
||||
i = strings.Index(name, ".") |
||||
return name[i+1:] |
||||
} |
||||
@ -0,0 +1,4 @@ |
||||
logrus |
||||
vendor |
||||
|
||||
.idea/ |
||||
@ -0,0 +1,40 @@ |
||||
run: |
||||
# do not run on test files yet |
||||
tests: false |
||||
|
||||
# all available settings of specific linters |
||||
linters-settings: |
||||
errcheck: |
||||
# report about not checking of errors in type assetions: `a := b.(MyStruct)`; |
||||
# default is false: such cases aren't reported by default. |
||||
check-type-assertions: false |
||||
|
||||
# report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`; |
||||
# default is false: such cases aren't reported by default. |
||||
check-blank: false |
||||
|
||||
lll: |
||||
line-length: 100 |
||||
tab-width: 4 |
||||
|
||||
prealloc: |
||||
simple: false |
||||
range-loops: false |
||||
for-loops: false |
||||
|
||||
whitespace: |
||||
multi-if: false # Enforces newlines (or comments) after every multi-line if statement |
||||
multi-func: false # Enforces newlines (or comments) after every multi-line function signature |
||||
|
||||
linters: |
||||
enable: |
||||
- megacheck |
||||
- govet |
||||
disable: |
||||
- maligned |
||||
- prealloc |
||||
disable-all: false |
||||
presets: |
||||
- bugs |
||||
- unused |
||||
fast: false |
||||
@ -0,0 +1,15 @@ |
||||
language: go |
||||
go_import_path: github.com/sirupsen/logrus |
||||
git: |
||||
depth: 1 |
||||
env: |
||||
- GO111MODULE=on |
||||
go: 1.15.x |
||||
os: linux |
||||
install: |
||||
- ./travis/install.sh |
||||
script: |
||||
- cd ci |
||||
- go run mage.go -v -w ../ crossBuild |
||||
- go run mage.go -v -w ../ lint |
||||
- go run mage.go -v -w ../ test |
||||
@ -0,0 +1,259 @@ |
||||
# 1.8.1 |
||||
Code quality: |
||||
* move magefile in its own subdir/submodule to remove magefile dependency on logrus consumer |
||||
* improve timestamp format documentation |
||||
|
||||
Fixes: |
||||
* fix race condition on logger hooks |
||||
|
||||
|
||||
# 1.8.0 |
||||
|
||||
Correct versioning number replacing v1.7.1. |
||||
|
||||
# 1.7.1 |
||||
|
||||
Beware this release has introduced a new public API and its semver is therefore incorrect. |
||||
|
||||
Code quality: |
||||
* use go 1.15 in travis |
||||
* use magefile as task runner |
||||
|
||||
Fixes: |
||||
* small fixes about new go 1.13 error formatting system |
||||
* Fix for long time race condiction with mutating data hooks |
||||
|
||||
Features: |
||||
* build support for zos |
||||
|
||||
# 1.7.0 |
||||
Fixes: |
||||
* the dependency toward a windows terminal library has been removed |
||||
|
||||
Features: |
||||
* a new buffer pool management API has been added |
||||
* a set of `<LogLevel>Fn()` functions have been added |
||||
|
||||
# 1.6.0 |
||||
Fixes: |
||||
* end of line cleanup |
||||
* revert the entry concurrency bug fix whic leads to deadlock under some circumstances |
||||
* update dependency on go-windows-terminal-sequences to fix a crash with go 1.14 |
||||
|
||||
Features: |
||||
* add an option to the `TextFormatter` to completely disable fields quoting |
||||
|
||||
# 1.5.0 |
||||
Code quality: |
||||
* add golangci linter run on travis |
||||
|
||||
Fixes: |
||||
* add mutex for hooks concurrent access on `Entry` data |
||||
* caller function field for go1.14 |
||||
* fix build issue for gopherjs target |
||||
|
||||
Feature: |
||||
* add an hooks/writer sub-package whose goal is to split output on different stream depending on the trace level |
||||
* add a `DisableHTMLEscape` option in the `JSONFormatter` |
||||
* add `ForceQuote` and `PadLevelText` options in the `TextFormatter` |
||||
|
||||
# 1.4.2 |
||||
* Fixes build break for plan9, nacl, solaris |
||||
# 1.4.1 |
||||
This new release introduces: |
||||
* Enhance TextFormatter to not print caller information when they are empty (#944) |
||||
* Remove dependency on golang.org/x/crypto (#932, #943) |
||||
|
||||
Fixes: |
||||
* Fix Entry.WithContext method to return a copy of the initial entry (#941) |
||||
|
||||
# 1.4.0 |
||||
This new release introduces: |
||||
* Add `DeferExitHandler`, similar to `RegisterExitHandler` but prepending the handler to the list of handlers (semantically like `defer`) (#848). |
||||
* Add `CallerPrettyfier` to `JSONFormatter` and `TextFormatter` (#909, #911) |
||||
* Add `Entry.WithContext()` and `Entry.Context`, to set a context on entries to be used e.g. in hooks (#919). |
||||
|
||||
Fixes: |
||||
* Fix wrong method calls `Logger.Print` and `Logger.Warningln` (#893). |
||||
* Update `Entry.Logf` to not do string formatting unless the log level is enabled (#903) |
||||
* Fix infinite recursion on unknown `Level.String()` (#907) |
||||
* Fix race condition in `getCaller` (#916). |
||||
|
||||
|
||||
# 1.3.0 |
||||
This new release introduces: |
||||
* Log, Logf, Logln functions for Logger and Entry that take a Level |
||||
|
||||
Fixes: |
||||
* Building prometheus node_exporter on AIX (#840) |
||||
* Race condition in TextFormatter (#468) |
||||
* Travis CI import path (#868) |
||||
* Remove coloured output on Windows (#862) |
||||
* Pointer to func as field in JSONFormatter (#870) |
||||
* Properly marshal Levels (#873) |
||||
|
||||
# 1.2.0 |
||||
This new release introduces: |
||||
* A new method `SetReportCaller` in the `Logger` to enable the file, line and calling function from which the trace has been issued |
||||
* A new trace level named `Trace` whose level is below `Debug` |
||||
* A configurable exit function to be called upon a Fatal trace |
||||
* The `Level` object now implements `encoding.TextUnmarshaler` interface |
||||
|
||||
# 1.1.1 |
||||
This is a bug fix release. |
||||
* fix the build break on Solaris |
||||
* don't drop a whole trace in JSONFormatter when a field param is a function pointer which can not be serialized |
||||
|
||||
# 1.1.0 |
||||
This new release introduces: |
||||
* several fixes: |
||||
* a fix for a race condition on entry formatting |
||||
* proper cleanup of previously used entries before putting them back in the pool |
||||
* the extra new line at the end of message in text formatter has been removed |
||||
* a new global public API to check if a level is activated: IsLevelEnabled |
||||
* the following methods have been added to the Logger object |
||||
* IsLevelEnabled |
||||
* SetFormatter |
||||
* SetOutput |
||||
* ReplaceHooks |
||||
* introduction of go module |
||||
* an indent configuration for the json formatter |
||||
* output colour support for windows |
||||
* the field sort function is now configurable for text formatter |
||||
* the CLICOLOR and CLICOLOR\_FORCE environment variable support in text formater |
||||
|
||||
# 1.0.6 |
||||
|
||||
This new release introduces: |
||||
* a new api WithTime which allows to easily force the time of the log entry |
||||
which is mostly useful for logger wrapper |
||||
* a fix reverting the immutability of the entry given as parameter to the hooks |
||||
a new configuration field of the json formatter in order to put all the fields |
||||
in a nested dictionnary |
||||
* a new SetOutput method in the Logger |
||||
* a new configuration of the textformatter to configure the name of the default keys |
||||
* a new configuration of the text formatter to disable the level truncation |
||||
|
||||
# 1.0.5 |
||||
|
||||
* Fix hooks race (#707) |
||||
* Fix panic deadlock (#695) |
||||
|
||||
# 1.0.4 |
||||
|
||||
* Fix race when adding hooks (#612) |
||||
* Fix terminal check in AppEngine (#635) |
||||
|
||||
# 1.0.3 |
||||
|
||||
* Replace example files with testable examples |
||||
|
||||
# 1.0.2 |
||||
|
||||
* bug: quote non-string values in text formatter (#583) |
||||
* Make (*Logger) SetLevel a public method |
||||
|
||||
# 1.0.1 |
||||
|
||||
* bug: fix escaping in text formatter (#575) |
||||
|
||||
# 1.0.0 |
||||
|
||||
* Officially changed name to lower-case |
||||
* bug: colors on Windows 10 (#541) |
||||
* bug: fix race in accessing level (#512) |
||||
|
||||
# 0.11.5 |
||||
|
||||
* feature: add writer and writerlevel to entry (#372) |
||||
|
||||
# 0.11.4 |
||||
|
||||
* bug: fix undefined variable on solaris (#493) |
||||
|
||||
# 0.11.3 |
||||
|
||||
* formatter: configure quoting of empty values (#484) |
||||
* formatter: configure quoting character (default is `"`) (#484) |
||||
* bug: fix not importing io correctly in non-linux environments (#481) |
||||
|
||||
# 0.11.2 |
||||
|
||||
* bug: fix windows terminal detection (#476) |
||||
|
||||
# 0.11.1 |
||||
|
||||
* bug: fix tty detection with custom out (#471) |
||||
|
||||
# 0.11.0 |
||||
|
||||
* performance: Use bufferpool to allocate (#370) |
||||
* terminal: terminal detection for app-engine (#343) |
||||
* feature: exit handler (#375) |
||||
|
||||
# 0.10.0 |
||||
|
||||
* feature: Add a test hook (#180) |
||||
* feature: `ParseLevel` is now case-insensitive (#326) |
||||
* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308) |
||||
* performance: avoid re-allocations on `WithFields` (#335) |
||||
|
||||
# 0.9.0 |
||||
|
||||
* logrus/text_formatter: don't emit empty msg |
||||
* logrus/hooks/airbrake: move out of main repository |
||||
* logrus/hooks/sentry: move out of main repository |
||||
* logrus/hooks/papertrail: move out of main repository |
||||
* logrus/hooks/bugsnag: move out of main repository |
||||
* logrus/core: run tests with `-race` |
||||
* logrus/core: detect TTY based on `stderr` |
||||
* logrus/core: support `WithError` on logger |
||||
* logrus/core: Solaris support |
||||
|
||||
# 0.8.7 |
||||
|
||||
* logrus/core: fix possible race (#216) |
||||
* logrus/doc: small typo fixes and doc improvements |
||||
|
||||
|
||||
# 0.8.6 |
||||
|
||||
* hooks/raven: allow passing an initialized client |
||||
|
||||
# 0.8.5 |
||||
|
||||
* logrus/core: revert #208 |
||||
|
||||
# 0.8.4 |
||||
|
||||
* formatter/text: fix data race (#218) |
||||
|
||||
# 0.8.3 |
||||
|
||||
* logrus/core: fix entry log level (#208) |
||||
* logrus/core: improve performance of text formatter by 40% |
||||
* logrus/core: expose `LevelHooks` type |
||||
* logrus/core: add support for DragonflyBSD and NetBSD |
||||
* formatter/text: print structs more verbosely |
||||
|
||||
# 0.8.2 |
||||
|
||||
* logrus: fix more Fatal family functions |
||||
|
||||
# 0.8.1 |
||||
|
||||
* logrus: fix not exiting on `Fatalf` and `Fatalln` |
||||
|
||||
# 0.8.0 |
||||
|
||||
* logrus: defaults to stderr instead of stdout |
||||
* hooks/sentry: add special field for `*http.Request` |
||||
* formatter/text: ignore Windows for colors |
||||
|
||||
# 0.7.3 |
||||
|
||||
* formatter/\*: allow configuration of timestamp layout |
||||
|
||||
# 0.7.2 |
||||
|
||||
* formatter/text: Add configuration option for time format (#158) |
||||
@ -0,0 +1,21 @@ |
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2014 Simon Eskildsen |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
@ -0,0 +1,513 @@ |
||||
# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/> [](https://github.com/sirupsen/logrus/actions?query=workflow%3ACI) [](https://travis-ci.org/sirupsen/logrus) [](https://pkg.go.dev/github.com/sirupsen/logrus) |
||||
|
||||
Logrus is a structured logger for Go (golang), completely API compatible with |
||||
the standard library logger. |
||||
|
||||
**Logrus is in maintenance-mode.** We will not be introducing new features. It's |
||||
simply too hard to do in a way that won't break many people's projects, which is |
||||
the last thing you want from your Logging library (again...). |
||||
|
||||
This does not mean Logrus is dead. Logrus will continue to be maintained for |
||||
security, (backwards compatible) bug fixes, and performance (where we are |
||||
limited by the interface). |
||||
|
||||
I believe Logrus' biggest contribution is to have played a part in today's |
||||
widespread use of structured logging in Golang. There doesn't seem to be a |
||||
reason to do a major, breaking iteration into Logrus V2, since the fantastic Go |
||||
community has built those independently. Many fantastic alternatives have sprung |
||||
up. Logrus would look like those, had it been re-designed with what we know |
||||
about structured logging in Go today. Check out, for example, |
||||
[Zerolog][zerolog], [Zap][zap], and [Apex][apex]. |
||||
|
||||
[zerolog]: https://github.com/rs/zerolog |
||||
[zap]: https://github.com/uber-go/zap |
||||
[apex]: https://github.com/apex/log |
||||
|
||||
**Seeing weird case-sensitive problems?** It's in the past been possible to |
||||
import Logrus as both upper- and lower-case. Due to the Go package environment, |
||||
this caused issues in the community and we needed a standard. Some environments |
||||
experienced problems with the upper-case variant, so the lower-case was decided. |
||||
Everything using `logrus` will need to use the lower-case: |
||||
`github.com/sirupsen/logrus`. Any package that isn't, should be changed. |
||||
|
||||
To fix Glide, see [these |
||||
comments](https://github.com/sirupsen/logrus/issues/553#issuecomment-306591437). |
||||
For an in-depth explanation of the casing issue, see [this |
||||
comment](https://github.com/sirupsen/logrus/issues/570#issuecomment-313933276). |
||||
|
||||
Nicely color-coded in development (when a TTY is attached, otherwise just |
||||
plain text): |
||||
|
||||
 |
||||
|
||||
With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash |
||||
or Splunk: |
||||
|
||||
```json |
||||
{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the |
||||
ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"} |
||||
|
||||
{"level":"warning","msg":"The group's number increased tremendously!", |
||||
"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"} |
||||
|
||||
{"animal":"walrus","level":"info","msg":"A giant walrus appears!", |
||||
"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"} |
||||
|
||||
{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.", |
||||
"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"} |
||||
|
||||
{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true, |
||||
"time":"2014-03-10 19:57:38.562543128 -0400 EDT"} |
||||
``` |
||||
|
||||
With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not |
||||
attached, the output is compatible with the |
||||
[logfmt](http://godoc.org/github.com/kr/logfmt) format: |
||||
|
||||
```text |
||||
time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8 |
||||
time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10 |
||||
time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true |
||||
time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4 |
||||
time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009 |
||||
time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true |
||||
``` |
||||
To ensure this behaviour even if a TTY is attached, set your formatter as follows: |
||||
|
||||
```go |
||||
log.SetFormatter(&log.TextFormatter{ |
||||
DisableColors: true, |
||||
FullTimestamp: true, |
||||
}) |
||||
``` |
||||
|
||||
#### Logging Method Name |
||||
|
||||
If you wish to add the calling method as a field, instruct the logger via: |
||||
```go |
||||
log.SetReportCaller(true) |
||||
``` |
||||
This adds the caller as 'method' like so: |
||||
|
||||
```json |
||||
{"animal":"penguin","level":"fatal","method":"github.com/sirupsen/arcticcreatures.migrate","msg":"a penguin swims by", |
||||
"time":"2014-03-10 19:57:38.562543129 -0400 EDT"} |
||||
``` |
||||
|
||||
```text |
||||
time="2015-03-26T01:27:38-04:00" level=fatal method=github.com/sirupsen/arcticcreatures.migrate msg="a penguin swims by" animal=penguin |
||||
``` |
||||
Note that this does add measurable overhead - the cost will depend on the version of Go, but is |
||||
between 20 and 40% in recent tests with 1.6 and 1.7. You can validate this in your |
||||
environment via benchmarks: |
||||
``` |
||||
go test -bench=.*CallerTracing |
||||
``` |
||||
|
||||
|
||||
#### Case-sensitivity |
||||
|
||||
The organization's name was changed to lower-case--and this will not be changed |
||||
back. If you are getting import conflicts due to case sensitivity, please use |
||||
the lower-case import: `github.com/sirupsen/logrus`. |
||||
|
||||
#### Example |
||||
|
||||
The simplest way to use Logrus is simply the package-level exported logger: |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
log "github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
func main() { |
||||
log.WithFields(log.Fields{ |
||||
"animal": "walrus", |
||||
}).Info("A walrus appears") |
||||
} |
||||
``` |
||||
|
||||
Note that it's completely api-compatible with the stdlib logger, so you can |
||||
replace your `log` imports everywhere with `log "github.com/sirupsen/logrus"` |
||||
and you'll now have the flexibility of Logrus. You can customize it all you |
||||
want: |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"os" |
||||
log "github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
func init() { |
||||
// Log as JSON instead of the default ASCII formatter. |
||||
log.SetFormatter(&log.JSONFormatter{}) |
||||
|
||||
// Output to stdout instead of the default stderr |
||||
// Can be any io.Writer, see below for File example |
||||
log.SetOutput(os.Stdout) |
||||
|
||||
// Only log the warning severity or above. |
||||
log.SetLevel(log.WarnLevel) |
||||
} |
||||
|
||||
func main() { |
||||
log.WithFields(log.Fields{ |
||||
"animal": "walrus", |
||||
"size": 10, |
||||
}).Info("A group of walrus emerges from the ocean") |
||||
|
||||
log.WithFields(log.Fields{ |
||||
"omg": true, |
||||
"number": 122, |
||||
}).Warn("The group's number increased tremendously!") |
||||
|
||||
log.WithFields(log.Fields{ |
||||
"omg": true, |
||||
"number": 100, |
||||
}).Fatal("The ice breaks!") |
||||
|
||||
// A common pattern is to re-use fields between logging statements by re-using |
||||
// the logrus.Entry returned from WithFields() |
||||
contextLogger := log.WithFields(log.Fields{ |
||||
"common": "this is a common field", |
||||
"other": "I also should be logged always", |
||||
}) |
||||
|
||||
contextLogger.Info("I'll be logged with common and other field") |
||||
contextLogger.Info("Me too") |
||||
} |
||||
``` |
||||
|
||||
For more advanced usage such as logging to multiple locations from the same |
||||
application, you can also create an instance of the `logrus` Logger: |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"os" |
||||
"github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
// Create a new instance of the logger. You can have any number of instances. |
||||
var log = logrus.New() |
||||
|
||||
func main() { |
||||
// The API for setting attributes is a little different than the package level |
||||
// exported logger. See Godoc. |
||||
log.Out = os.Stdout |
||||
|
||||
// You could set this to any `io.Writer` such as a file |
||||
// file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) |
||||
// if err == nil { |
||||
// log.Out = file |
||||
// } else { |
||||
// log.Info("Failed to log to file, using default stderr") |
||||
// } |
||||
|
||||
log.WithFields(logrus.Fields{ |
||||
"animal": "walrus", |
||||
"size": 10, |
||||
}).Info("A group of walrus emerges from the ocean") |
||||
} |
||||
``` |
||||
|
||||
#### Fields |
||||
|
||||
Logrus encourages careful, structured logging through logging fields instead of |
||||
long, unparseable error messages. For example, instead of: `log.Fatalf("Failed |
||||
to send event %s to topic %s with key %d")`, you should log the much more |
||||
discoverable: |
||||
|
||||
```go |
||||
log.WithFields(log.Fields{ |
||||
"event": event, |
||||
"topic": topic, |
||||
"key": key, |
||||
}).Fatal("Failed to send event") |
||||
``` |
||||
|
||||
We've found this API forces you to think about logging in a way that produces |
||||
much more useful logging messages. We've been in countless situations where just |
||||
a single added field to a log statement that was already there would've saved us |
||||
hours. The `WithFields` call is optional. |
||||
|
||||
In general, with Logrus using any of the `printf`-family functions should be |
||||
seen as a hint you should add a field, however, you can still use the |
||||
`printf`-family functions with Logrus. |
||||
|
||||
#### Default Fields |
||||
|
||||
Often it's helpful to have fields _always_ attached to log statements in an |
||||
application or parts of one. For example, you may want to always log the |
||||
`request_id` and `user_ip` in the context of a request. Instead of writing |
||||
`log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})` on |
||||
every line, you can create a `logrus.Entry` to pass around instead: |
||||
|
||||
```go |
||||
requestLogger := log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip}) |
||||
requestLogger.Info("something happened on that request") # will log request_id and user_ip |
||||
requestLogger.Warn("something not great happened") |
||||
``` |
||||
|
||||
#### Hooks |
||||
|
||||
You can add hooks for logging levels. For example to send errors to an exception |
||||
tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to |
||||
multiple places simultaneously, e.g. syslog. |
||||
|
||||
Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in |
||||
`init`: |
||||
|
||||
```go |
||||
import ( |
||||
log "github.com/sirupsen/logrus" |
||||
"gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "airbrake" |
||||
logrus_syslog "github.com/sirupsen/logrus/hooks/syslog" |
||||
"log/syslog" |
||||
) |
||||
|
||||
func init() { |
||||
|
||||
// Use the Airbrake hook to report errors that have Error severity or above to |
||||
// an exception tracker. You can create custom hooks, see the Hooks section. |
||||
log.AddHook(airbrake.NewHook(123, "xyz", "production")) |
||||
|
||||
hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "") |
||||
if err != nil { |
||||
log.Error("Unable to connect to local syslog daemon") |
||||
} else { |
||||
log.AddHook(hook) |
||||
} |
||||
} |
||||
``` |
||||
Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md). |
||||
|
||||
A list of currently known service hooks can be found in this wiki [page](https://github.com/sirupsen/logrus/wiki/Hooks) |
||||
|
||||
|
||||
#### Level logging |
||||
|
||||
Logrus has seven logging levels: Trace, Debug, Info, Warning, Error, Fatal and Panic. |
||||
|
||||
```go |
||||
log.Trace("Something very low level.") |
||||
log.Debug("Useful debugging information.") |
||||
log.Info("Something noteworthy happened!") |
||||
log.Warn("You should probably take a look at this.") |
||||
log.Error("Something failed but I'm not quitting.") |
||||
// Calls os.Exit(1) after logging |
||||
log.Fatal("Bye.") |
||||
// Calls panic() after logging |
||||
log.Panic("I'm bailing.") |
||||
``` |
||||
|
||||
You can set the logging level on a `Logger`, then it will only log entries with |
||||
that severity or anything above it: |
||||
|
||||
```go |
||||
// Will log anything that is info or above (warn, error, fatal, panic). Default. |
||||
log.SetLevel(log.InfoLevel) |
||||
``` |
||||
|
||||
It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose |
||||
environment if your application has that. |
||||
|
||||
#### Entries |
||||
|
||||
Besides the fields added with `WithField` or `WithFields` some fields are |
||||
automatically added to all logging events: |
||||
|
||||
1. `time`. The timestamp when the entry was created. |
||||
2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after |
||||
the `AddFields` call. E.g. `Failed to send event.` |
||||
3. `level`. The logging level. E.g. `info`. |
||||
|
||||
#### Environments |
||||
|
||||
Logrus has no notion of environment. |
||||
|
||||
If you wish for hooks and formatters to only be used in specific environments, |
||||
you should handle that yourself. For example, if your application has a global |
||||
variable `Environment`, which is a string representation of the environment you |
||||
could do: |
||||
|
||||
```go |
||||
import ( |
||||
log "github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
func init() { |
||||
// do something here to set environment depending on an environment variable |
||||
// or command-line flag |
||||
if Environment == "production" { |
||||
log.SetFormatter(&log.JSONFormatter{}) |
||||
} else { |
||||
// The TextFormatter is default, you don't actually have to do this. |
||||
log.SetFormatter(&log.TextFormatter{}) |
||||
} |
||||
} |
||||
``` |
||||
|
||||
This configuration is how `logrus` was intended to be used, but JSON in |
||||
production is mostly only useful if you do log aggregation with tools like |
||||
Splunk or Logstash. |
||||
|
||||
#### Formatters |
||||
|
||||
The built-in logging formatters are: |
||||
|
||||
* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise |
||||
without colors. |
||||
* *Note:* to force colored output when there is no TTY, set the `ForceColors` |
||||
field to `true`. To force no colored output even if there is a TTY set the |
||||
`DisableColors` field to `true`. For Windows, see |
||||
[github.com/mattn/go-colorable](https://github.com/mattn/go-colorable). |
||||
* When colors are enabled, levels are truncated to 4 characters by default. To disable |
||||
truncation set the `DisableLevelTruncation` field to `true`. |
||||
* When outputting to a TTY, it's often helpful to visually scan down a column where all the levels are the same width. Setting the `PadLevelText` field to `true` enables this behavior, by adding padding to the level text. |
||||
* All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#TextFormatter). |
||||
* `logrus.JSONFormatter`. Logs fields as JSON. |
||||
* All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#JSONFormatter). |
||||
|
||||
Third party logging formatters: |
||||
|
||||
* [`FluentdFormatter`](https://github.com/joonix/log). Formats entries that can be parsed by Kubernetes and Google Container Engine. |
||||
* [`GELF`](https://github.com/fabienm/go-logrus-formatters). Formats entries so they comply to Graylog's [GELF 1.1 specification](http://docs.graylog.org/en/2.4/pages/gelf.html). |
||||
* [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events. |
||||
* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout. |
||||
* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the Power of Zalgo. |
||||
* [`nested-logrus-formatter`](https://github.com/antonfisher/nested-logrus-formatter). Converts logrus fields to a nested structure. |
||||
* [`powerful-logrus-formatter`](https://github.com/zput/zxcTool). get fileName, log's line number and the latest function's name when print log; Sava log to files. |
||||
* [`caption-json-formatter`](https://github.com/nolleh/caption_json_formatter). logrus's message json formatter with human-readable caption added. |
||||
|
||||
You can define your formatter by implementing the `Formatter` interface, |
||||
requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a |
||||
`Fields` type (`map[string]interface{}`) with all your fields as well as the |
||||
default ones (see Entries section above): |
||||
|
||||
```go |
||||
type MyJSONFormatter struct { |
||||
} |
||||
|
||||
log.SetFormatter(new(MyJSONFormatter)) |
||||
|
||||
func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) { |
||||
// Note this doesn't include Time, Level and Message which are available on |
||||
// the Entry. Consult `godoc` on information about those fields or read the |
||||
// source of the official loggers. |
||||
serialized, err := json.Marshal(entry.Data) |
||||
if err != nil { |
||||
return nil, fmt.Errorf("Failed to marshal fields to JSON, %w", err) |
||||
} |
||||
return append(serialized, '\n'), nil |
||||
} |
||||
``` |
||||
|
||||
#### Logger as an `io.Writer` |
||||
|
||||
Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it. |
||||
|
||||
```go |
||||
w := logger.Writer() |
||||
defer w.Close() |
||||
|
||||
srv := http.Server{ |
||||
// create a stdlib log.Logger that writes to |
||||
// logrus.Logger. |
||||
ErrorLog: log.New(w, "", 0), |
||||
} |
||||
``` |
||||
|
||||
Each line written to that writer will be printed the usual way, using formatters |
||||
and hooks. The level for those entries is `info`. |
||||
|
||||
This means that we can override the standard library logger easily: |
||||
|
||||
```go |
||||
logger := logrus.New() |
||||
logger.Formatter = &logrus.JSONFormatter{} |
||||
|
||||
// Use logrus for standard log output |
||||
// Note that `log` here references stdlib's log |
||||
// Not logrus imported under the name `log`. |
||||
log.SetOutput(logger.Writer()) |
||||
``` |
||||
|
||||
#### Rotation |
||||
|
||||
Log rotation is not provided with Logrus. Log rotation should be done by an |
||||
external program (like `logrotate(8)`) that can compress and delete old log |
||||
entries. It should not be a feature of the application-level logger. |
||||
|
||||
#### Tools |
||||
|
||||
| Tool | Description | |
||||
| ---- | ----------- | |
||||
|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will be generated with different configs in different environments.| |
||||
|[Logrus Viper Helper](https://github.com/heirko/go-contrib/tree/master/logrusHelper)|An Helper around Logrus to wrap with spf13/Viper to load configuration with fangs! And to simplify Logrus configuration use some behavior of [Logrus Mate](https://github.com/gogap/logrus_mate). [sample](https://github.com/heirko/iris-contrib/blob/master/middleware/logrus-logger/example) | |
||||
|
||||
#### Testing |
||||
|
||||
Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides: |
||||
|
||||
* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just adds the `test` hook |
||||
* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any): |
||||
|
||||
```go |
||||
import( |
||||
"github.com/sirupsen/logrus" |
||||
"github.com/sirupsen/logrus/hooks/test" |
||||
"github.com/stretchr/testify/assert" |
||||
"testing" |
||||
) |
||||
|
||||
func TestSomething(t*testing.T){ |
||||
logger, hook := test.NewNullLogger() |
||||
logger.Error("Helloerror") |
||||
|
||||
assert.Equal(t, 1, len(hook.Entries)) |
||||
assert.Equal(t, logrus.ErrorLevel, hook.LastEntry().Level) |
||||
assert.Equal(t, "Helloerror", hook.LastEntry().Message) |
||||
|
||||
hook.Reset() |
||||
assert.Nil(t, hook.LastEntry()) |
||||
} |
||||
``` |
||||
|
||||
#### Fatal handlers |
||||
|
||||
Logrus can register one or more functions that will be called when any `fatal` |
||||
level message is logged. The registered handlers will be executed before |
||||
logrus performs an `os.Exit(1)`. This behavior may be helpful if callers need |
||||
to gracefully shutdown. Unlike a `panic("Something went wrong...")` call which can be intercepted with a deferred `recover` a call to `os.Exit(1)` can not be intercepted. |
||||
|
||||
``` |
||||
... |
||||
handler := func() { |
||||
// gracefully shutdown something... |
||||
} |
||||
logrus.RegisterExitHandler(handler) |
||||
... |
||||
``` |
||||
|
||||
#### Thread safety |
||||
|
||||
By default, Logger is protected by a mutex for concurrent writes. The mutex is held when calling hooks and writing logs. |
||||
If you are sure such locking is not needed, you can call logger.SetNoLock() to disable the locking. |
||||
|
||||
Situation when locking is not needed includes: |
||||
|
||||
* You have no hooks registered, or hooks calling is already thread-safe. |
||||
|
||||
* Writing to logger.Out is already thread-safe, for example: |
||||
|
||||
1) logger.Out is protected by locks. |
||||
|
||||
2) logger.Out is an os.File handler opened with `O_APPEND` flag, and every write is smaller than 4k. (This allows multi-thread/multi-process writing) |
||||
|
||||
(Refer to http://www.notthewizard.com/2014/06/17/are-files-appends-really-atomic/) |
||||
@ -0,0 +1,76 @@ |
||||
package logrus |
||||
|
||||
// The following code was sourced and modified from the
|
||||
// https://github.com/tebeka/atexit package governed by the following license:
|
||||
//
|
||||
// Copyright (c) 2012 Miki Tebeka <miki.tebeka@gmail.com>.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
// this software and associated documentation files (the "Software"), to deal in
|
||||
// the Software without restriction, including without limitation the rights to
|
||||
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
// the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
import ( |
||||
"fmt" |
||||
"os" |
||||
) |
||||
|
||||
var handlers = []func(){} |
||||
|
||||
func runHandler(handler func()) { |
||||
defer func() { |
||||
if err := recover(); err != nil { |
||||
fmt.Fprintln(os.Stderr, "Error: Logrus exit handler error:", err) |
||||
} |
||||
}() |
||||
|
||||
handler() |
||||
} |
||||
|
||||
func runHandlers() { |
||||
for _, handler := range handlers { |
||||
runHandler(handler) |
||||
} |
||||
} |
||||
|
||||
// Exit runs all the Logrus atexit handlers and then terminates the program using os.Exit(code)
|
||||
func Exit(code int) { |
||||
runHandlers() |
||||
os.Exit(code) |
||||
} |
||||
|
||||
// RegisterExitHandler appends a Logrus Exit handler to the list of handlers,
|
||||
// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
|
||||
// any Fatal log entry is made.
|
||||
//
|
||||
// This method is useful when a caller wishes to use logrus to log a fatal
|
||||
// message but also needs to gracefully shutdown. An example usecase could be
|
||||
// closing database connections, or sending a alert that the application is
|
||||
// closing.
|
||||
func RegisterExitHandler(handler func()) { |
||||
handlers = append(handlers, handler) |
||||
} |
||||
|
||||
// DeferExitHandler prepends a Logrus Exit handler to the list of handlers,
|
||||
// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
|
||||
// any Fatal log entry is made.
|
||||
//
|
||||
// This method is useful when a caller wishes to use logrus to log a fatal
|
||||
// message but also needs to gracefully shutdown. An example usecase could be
|
||||
// closing database connections, or sending a alert that the application is
|
||||
// closing.
|
||||
func DeferExitHandler(handler func()) { |
||||
handlers = append([]func(){handler}, handlers...) |
||||
} |
||||
@ -0,0 +1,14 @@ |
||||
version: "{build}" |
||||
platform: x64 |
||||
clone_folder: c:\gopath\src\github.com\sirupsen\logrus |
||||
environment: |
||||
GOPATH: c:\gopath |
||||
branches: |
||||
only: |
||||
- master |
||||
install: |
||||
- set PATH=%GOPATH%\bin;c:\go\bin;%PATH% |
||||
- go version |
||||
build_script: |
||||
- go get -t |
||||
- go test |
||||
@ -0,0 +1,43 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"bytes" |
||||
"sync" |
||||
) |
||||
|
||||
var ( |
||||
bufferPool BufferPool |
||||
) |
||||
|
||||
type BufferPool interface { |
||||
Put(*bytes.Buffer) |
||||
Get() *bytes.Buffer |
||||
} |
||||
|
||||
type defaultPool struct { |
||||
pool *sync.Pool |
||||
} |
||||
|
||||
func (p *defaultPool) Put(buf *bytes.Buffer) { |
||||
p.pool.Put(buf) |
||||
} |
||||
|
||||
func (p *defaultPool) Get() *bytes.Buffer { |
||||
return p.pool.Get().(*bytes.Buffer) |
||||
} |
||||
|
||||
// SetBufferPool allows to replace the default logrus buffer pool
|
||||
// to better meets the specific needs of an application.
|
||||
func SetBufferPool(bp BufferPool) { |
||||
bufferPool = bp |
||||
} |
||||
|
||||
func init() { |
||||
SetBufferPool(&defaultPool{ |
||||
pool: &sync.Pool{ |
||||
New: func() interface{} { |
||||
return new(bytes.Buffer) |
||||
}, |
||||
}, |
||||
}) |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
/* |
||||
Package logrus is a structured logger for Go, completely API compatible with the standard library logger. |
||||
|
||||
|
||||
The simplest way to use Logrus is simply the package-level exported logger: |
||||
|
||||
package main |
||||
|
||||
import ( |
||||
log "github.com/sirupsen/logrus" |
||||
) |
||||
|
||||
func main() { |
||||
log.WithFields(log.Fields{ |
||||
"animal": "walrus", |
||||
"number": 1, |
||||
"size": 10, |
||||
}).Info("A walrus appears") |
||||
} |
||||
|
||||
Output: |
||||
time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10 |
||||
|
||||
For a full guide visit https://github.com/sirupsen/logrus
|
||||
*/ |
||||
package logrus |
||||
@ -0,0 +1,442 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"bytes" |
||||
"context" |
||||
"fmt" |
||||
"os" |
||||
"reflect" |
||||
"runtime" |
||||
"strings" |
||||
"sync" |
||||
"time" |
||||
) |
||||
|
||||
var ( |
||||
|
||||
// qualified package name, cached at first use
|
||||
logrusPackage string |
||||
|
||||
// Positions in the call stack when tracing to report the calling method
|
||||
minimumCallerDepth int |
||||
|
||||
// Used for caller information initialisation
|
||||
callerInitOnce sync.Once |
||||
) |
||||
|
||||
const ( |
||||
maximumCallerDepth int = 25 |
||||
knownLogrusFrames int = 4 |
||||
) |
||||
|
||||
func init() { |
||||
// start at the bottom of the stack before the package-name cache is primed
|
||||
minimumCallerDepth = 1 |
||||
} |
||||
|
||||
// Defines the key when adding errors using WithError.
|
||||
var ErrorKey = "error" |
||||
|
||||
// An entry is the final or intermediate Logrus logging entry. It contains all
|
||||
// the fields passed with WithField{,s}. It's finally logged when Trace, Debug,
|
||||
// Info, Warn, Error, Fatal or Panic is called on it. These objects can be
|
||||
// reused and passed around as much as you wish to avoid field duplication.
|
||||
type Entry struct { |
||||
Logger *Logger |
||||
|
||||
// Contains all the fields set by the user.
|
||||
Data Fields |
||||
|
||||
// Time at which the log entry was created
|
||||
Time time.Time |
||||
|
||||
// Level the log entry was logged at: Trace, Debug, Info, Warn, Error, Fatal or Panic
|
||||
// This field will be set on entry firing and the value will be equal to the one in Logger struct field.
|
||||
Level Level |
||||
|
||||
// Calling method, with package name
|
||||
Caller *runtime.Frame |
||||
|
||||
// Message passed to Trace, Debug, Info, Warn, Error, Fatal or Panic
|
||||
Message string |
||||
|
||||
// When formatter is called in entry.log(), a Buffer may be set to entry
|
||||
Buffer *bytes.Buffer |
||||
|
||||
// Contains the context set by the user. Useful for hook processing etc.
|
||||
Context context.Context |
||||
|
||||
// err may contain a field formatting error
|
||||
err string |
||||
} |
||||
|
||||
func NewEntry(logger *Logger) *Entry { |
||||
return &Entry{ |
||||
Logger: logger, |
||||
// Default is three fields, plus one optional. Give a little extra room.
|
||||
Data: make(Fields, 6), |
||||
} |
||||
} |
||||
|
||||
func (entry *Entry) Dup() *Entry { |
||||
data := make(Fields, len(entry.Data)) |
||||
for k, v := range entry.Data { |
||||
data[k] = v |
||||
} |
||||
return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, Context: entry.Context, err: entry.err} |
||||
} |
||||
|
||||
// Returns the bytes representation of this entry from the formatter.
|
||||
func (entry *Entry) Bytes() ([]byte, error) { |
||||
return entry.Logger.Formatter.Format(entry) |
||||
} |
||||
|
||||
// Returns the string representation from the reader and ultimately the
|
||||
// formatter.
|
||||
func (entry *Entry) String() (string, error) { |
||||
serialized, err := entry.Bytes() |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
str := string(serialized) |
||||
return str, nil |
||||
} |
||||
|
||||
// Add an error as single field (using the key defined in ErrorKey) to the Entry.
|
||||
func (entry *Entry) WithError(err error) *Entry { |
||||
return entry.WithField(ErrorKey, err) |
||||
} |
||||
|
||||
// Add a context to the Entry.
|
||||
func (entry *Entry) WithContext(ctx context.Context) *Entry { |
||||
dataCopy := make(Fields, len(entry.Data)) |
||||
for k, v := range entry.Data { |
||||
dataCopy[k] = v |
||||
} |
||||
return &Entry{Logger: entry.Logger, Data: dataCopy, Time: entry.Time, err: entry.err, Context: ctx} |
||||
} |
||||
|
||||
// Add a single field to the Entry.
|
||||
func (entry *Entry) WithField(key string, value interface{}) *Entry { |
||||
return entry.WithFields(Fields{key: value}) |
||||
} |
||||
|
||||
// Add a map of fields to the Entry.
|
||||
func (entry *Entry) WithFields(fields Fields) *Entry { |
||||
data := make(Fields, len(entry.Data)+len(fields)) |
||||
for k, v := range entry.Data { |
||||
data[k] = v |
||||
} |
||||
fieldErr := entry.err |
||||
for k, v := range fields { |
||||
isErrField := false |
||||
if t := reflect.TypeOf(v); t != nil { |
||||
switch { |
||||
case t.Kind() == reflect.Func, t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Func: |
||||
isErrField = true |
||||
} |
||||
} |
||||
if isErrField { |
||||
tmp := fmt.Sprintf("can not add field %q", k) |
||||
if fieldErr != "" { |
||||
fieldErr = entry.err + ", " + tmp |
||||
} else { |
||||
fieldErr = tmp |
||||
} |
||||
} else { |
||||
data[k] = v |
||||
} |
||||
} |
||||
return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context} |
||||
} |
||||
|
||||
// Overrides the time of the Entry.
|
||||
func (entry *Entry) WithTime(t time.Time) *Entry { |
||||
dataCopy := make(Fields, len(entry.Data)) |
||||
for k, v := range entry.Data { |
||||
dataCopy[k] = v |
||||
} |
||||
return &Entry{Logger: entry.Logger, Data: dataCopy, Time: t, err: entry.err, Context: entry.Context} |
||||
} |
||||
|
||||
// getPackageName reduces a fully qualified function name to the package name
|
||||
// There really ought to be to be a better way...
|
||||
func getPackageName(f string) string { |
||||
for { |
||||
lastPeriod := strings.LastIndex(f, ".") |
||||
lastSlash := strings.LastIndex(f, "/") |
||||
if lastPeriod > lastSlash { |
||||
f = f[:lastPeriod] |
||||
} else { |
||||
break |
||||
} |
||||
} |
||||
|
||||
return f |
||||
} |
||||
|
||||
// getCaller retrieves the name of the first non-logrus calling function
|
||||
func getCaller() *runtime.Frame { |
||||
// cache this package's fully-qualified name
|
||||
callerInitOnce.Do(func() { |
||||
pcs := make([]uintptr, maximumCallerDepth) |
||||
_ = runtime.Callers(0, pcs) |
||||
|
||||
// dynamic get the package name and the minimum caller depth
|
||||
for i := 0; i < maximumCallerDepth; i++ { |
||||
funcName := runtime.FuncForPC(pcs[i]).Name() |
||||
if strings.Contains(funcName, "getCaller") { |
||||
logrusPackage = getPackageName(funcName) |
||||
break |
||||
} |
||||
} |
||||
|
||||
minimumCallerDepth = knownLogrusFrames |
||||
}) |
||||
|
||||
// Restrict the lookback frames to avoid runaway lookups
|
||||
pcs := make([]uintptr, maximumCallerDepth) |
||||
depth := runtime.Callers(minimumCallerDepth, pcs) |
||||
frames := runtime.CallersFrames(pcs[:depth]) |
||||
|
||||
for f, again := frames.Next(); again; f, again = frames.Next() { |
||||
pkg := getPackageName(f.Function) |
||||
|
||||
// If the caller isn't part of this package, we're done
|
||||
if pkg != logrusPackage { |
||||
return &f //nolint:scopelint
|
||||
} |
||||
} |
||||
|
||||
// if we got here, we failed to find the caller's context
|
||||
return nil |
||||
} |
||||
|
||||
func (entry Entry) HasCaller() (has bool) { |
||||
return entry.Logger != nil && |
||||
entry.Logger.ReportCaller && |
||||
entry.Caller != nil |
||||
} |
||||
|
||||
func (entry *Entry) log(level Level, msg string) { |
||||
var buffer *bytes.Buffer |
||||
|
||||
newEntry := entry.Dup() |
||||
|
||||
if newEntry.Time.IsZero() { |
||||
newEntry.Time = time.Now() |
||||
} |
||||
|
||||
newEntry.Level = level |
||||
newEntry.Message = msg |
||||
|
||||
newEntry.Logger.mu.Lock() |
||||
reportCaller := newEntry.Logger.ReportCaller |
||||
bufPool := newEntry.getBufferPool() |
||||
newEntry.Logger.mu.Unlock() |
||||
|
||||
if reportCaller { |
||||
newEntry.Caller = getCaller() |
||||
} |
||||
|
||||
newEntry.fireHooks() |
||||
buffer = bufPool.Get() |
||||
defer func() { |
||||
newEntry.Buffer = nil |
||||
buffer.Reset() |
||||
bufPool.Put(buffer) |
||||
}() |
||||
buffer.Reset() |
||||
newEntry.Buffer = buffer |
||||
|
||||
newEntry.write() |
||||
|
||||
newEntry.Buffer = nil |
||||
|
||||
// To avoid Entry#log() returning a value that only would make sense for
|
||||
// panic() to use in Entry#Panic(), we avoid the allocation by checking
|
||||
// directly here.
|
||||
if level <= PanicLevel { |
||||
panic(newEntry) |
||||
} |
||||
} |
||||
|
||||
func (entry *Entry) getBufferPool() (pool BufferPool) { |
||||
if entry.Logger.BufferPool != nil { |
||||
return entry.Logger.BufferPool |
||||
} |
||||
return bufferPool |
||||
} |
||||
|
||||
func (entry *Entry) fireHooks() { |
||||
var tmpHooks LevelHooks |
||||
entry.Logger.mu.Lock() |
||||
tmpHooks = make(LevelHooks, len(entry.Logger.Hooks)) |
||||
for k, v := range entry.Logger.Hooks { |
||||
tmpHooks[k] = v |
||||
} |
||||
entry.Logger.mu.Unlock() |
||||
|
||||
err := tmpHooks.Fire(entry.Level, entry) |
||||
if err != nil { |
||||
fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err) |
||||
} |
||||
} |
||||
|
||||
func (entry *Entry) write() { |
||||
entry.Logger.mu.Lock() |
||||
defer entry.Logger.mu.Unlock() |
||||
serialized, err := entry.Logger.Formatter.Format(entry) |
||||
if err != nil { |
||||
fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err) |
||||
return |
||||
} |
||||
if _, err := entry.Logger.Out.Write(serialized); err != nil { |
||||
fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err) |
||||
} |
||||
} |
||||
|
||||
// Log will log a message at the level given as parameter.
|
||||
// Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
|
||||
// For this behaviour Entry.Panic or Entry.Fatal should be used instead.
|
||||
func (entry *Entry) Log(level Level, args ...interface{}) { |
||||
if entry.Logger.IsLevelEnabled(level) { |
||||
entry.log(level, fmt.Sprint(args...)) |
||||
} |
||||
} |
||||
|
||||
func (entry *Entry) Trace(args ...interface{}) { |
||||
entry.Log(TraceLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Debug(args ...interface{}) { |
||||
entry.Log(DebugLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Print(args ...interface{}) { |
||||
entry.Info(args...) |
||||
} |
||||
|
||||
func (entry *Entry) Info(args ...interface{}) { |
||||
entry.Log(InfoLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Warn(args ...interface{}) { |
||||
entry.Log(WarnLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Warning(args ...interface{}) { |
||||
entry.Warn(args...) |
||||
} |
||||
|
||||
func (entry *Entry) Error(args ...interface{}) { |
||||
entry.Log(ErrorLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Fatal(args ...interface{}) { |
||||
entry.Log(FatalLevel, args...) |
||||
entry.Logger.Exit(1) |
||||
} |
||||
|
||||
func (entry *Entry) Panic(args ...interface{}) { |
||||
entry.Log(PanicLevel, args...) |
||||
} |
||||
|
||||
// Entry Printf family functions
|
||||
|
||||
func (entry *Entry) Logf(level Level, format string, args ...interface{}) { |
||||
if entry.Logger.IsLevelEnabled(level) { |
||||
entry.Log(level, fmt.Sprintf(format, args...)) |
||||
} |
||||
} |
||||
|
||||
func (entry *Entry) Tracef(format string, args ...interface{}) { |
||||
entry.Logf(TraceLevel, format, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Debugf(format string, args ...interface{}) { |
||||
entry.Logf(DebugLevel, format, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Infof(format string, args ...interface{}) { |
||||
entry.Logf(InfoLevel, format, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Printf(format string, args ...interface{}) { |
||||
entry.Infof(format, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Warnf(format string, args ...interface{}) { |
||||
entry.Logf(WarnLevel, format, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Warningf(format string, args ...interface{}) { |
||||
entry.Warnf(format, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Errorf(format string, args ...interface{}) { |
||||
entry.Logf(ErrorLevel, format, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Fatalf(format string, args ...interface{}) { |
||||
entry.Logf(FatalLevel, format, args...) |
||||
entry.Logger.Exit(1) |
||||
} |
||||
|
||||
func (entry *Entry) Panicf(format string, args ...interface{}) { |
||||
entry.Logf(PanicLevel, format, args...) |
||||
} |
||||
|
||||
// Entry Println family functions
|
||||
|
||||
func (entry *Entry) Logln(level Level, args ...interface{}) { |
||||
if entry.Logger.IsLevelEnabled(level) { |
||||
entry.Log(level, entry.sprintlnn(args...)) |
||||
} |
||||
} |
||||
|
||||
func (entry *Entry) Traceln(args ...interface{}) { |
||||
entry.Logln(TraceLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Debugln(args ...interface{}) { |
||||
entry.Logln(DebugLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Infoln(args ...interface{}) { |
||||
entry.Logln(InfoLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Println(args ...interface{}) { |
||||
entry.Infoln(args...) |
||||
} |
||||
|
||||
func (entry *Entry) Warnln(args ...interface{}) { |
||||
entry.Logln(WarnLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Warningln(args ...interface{}) { |
||||
entry.Warnln(args...) |
||||
} |
||||
|
||||
func (entry *Entry) Errorln(args ...interface{}) { |
||||
entry.Logln(ErrorLevel, args...) |
||||
} |
||||
|
||||
func (entry *Entry) Fatalln(args ...interface{}) { |
||||
entry.Logln(FatalLevel, args...) |
||||
entry.Logger.Exit(1) |
||||
} |
||||
|
||||
func (entry *Entry) Panicln(args ...interface{}) { |
||||
entry.Logln(PanicLevel, args...) |
||||
} |
||||
|
||||
// Sprintlnn => Sprint no newline. This is to get the behavior of how
|
||||
// fmt.Sprintln where spaces are always added between operands, regardless of
|
||||
// their type. Instead of vendoring the Sprintln implementation to spare a
|
||||
// string allocation, we do the simplest thing.
|
||||
func (entry *Entry) sprintlnn(args ...interface{}) string { |
||||
msg := fmt.Sprintln(args...) |
||||
return msg[:len(msg)-1] |
||||
} |
||||
@ -0,0 +1,270 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"context" |
||||
"io" |
||||
"time" |
||||
) |
||||
|
||||
var ( |
||||
// std is the name of the standard logger in stdlib `log`
|
||||
std = New() |
||||
) |
||||
|
||||
func StandardLogger() *Logger { |
||||
return std |
||||
} |
||||
|
||||
// SetOutput sets the standard logger output.
|
||||
func SetOutput(out io.Writer) { |
||||
std.SetOutput(out) |
||||
} |
||||
|
||||
// SetFormatter sets the standard logger formatter.
|
||||
func SetFormatter(formatter Formatter) { |
||||
std.SetFormatter(formatter) |
||||
} |
||||
|
||||
// SetReportCaller sets whether the standard logger will include the calling
|
||||
// method as a field.
|
||||
func SetReportCaller(include bool) { |
||||
std.SetReportCaller(include) |
||||
} |
||||
|
||||
// SetLevel sets the standard logger level.
|
||||
func SetLevel(level Level) { |
||||
std.SetLevel(level) |
||||
} |
||||
|
||||
// GetLevel returns the standard logger level.
|
||||
func GetLevel() Level { |
||||
return std.GetLevel() |
||||
} |
||||
|
||||
// IsLevelEnabled checks if the log level of the standard logger is greater than the level param
|
||||
func IsLevelEnabled(level Level) bool { |
||||
return std.IsLevelEnabled(level) |
||||
} |
||||
|
||||
// AddHook adds a hook to the standard logger hooks.
|
||||
func AddHook(hook Hook) { |
||||
std.AddHook(hook) |
||||
} |
||||
|
||||
// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.
|
||||
func WithError(err error) *Entry { |
||||
return std.WithField(ErrorKey, err) |
||||
} |
||||
|
||||
// WithContext creates an entry from the standard logger and adds a context to it.
|
||||
func WithContext(ctx context.Context) *Entry { |
||||
return std.WithContext(ctx) |
||||
} |
||||
|
||||
// WithField creates an entry from the standard logger and adds a field to
|
||||
// it. If you want multiple fields, use `WithFields`.
|
||||
//
|
||||
// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
|
||||
// or Panic on the Entry it returns.
|
||||
func WithField(key string, value interface{}) *Entry { |
||||
return std.WithField(key, value) |
||||
} |
||||
|
||||
// WithFields creates an entry from the standard logger and adds multiple
|
||||
// fields to it. This is simply a helper for `WithField`, invoking it
|
||||
// once for each field.
|
||||
//
|
||||
// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
|
||||
// or Panic on the Entry it returns.
|
||||
func WithFields(fields Fields) *Entry { |
||||
return std.WithFields(fields) |
||||
} |
||||
|
||||
// WithTime creates an entry from the standard logger and overrides the time of
|
||||
// logs generated with it.
|
||||
//
|
||||
// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
|
||||
// or Panic on the Entry it returns.
|
||||
func WithTime(t time.Time) *Entry { |
||||
return std.WithTime(t) |
||||
} |
||||
|
||||
// Trace logs a message at level Trace on the standard logger.
|
||||
func Trace(args ...interface{}) { |
||||
std.Trace(args...) |
||||
} |
||||
|
||||
// Debug logs a message at level Debug on the standard logger.
|
||||
func Debug(args ...interface{}) { |
||||
std.Debug(args...) |
||||
} |
||||
|
||||
// Print logs a message at level Info on the standard logger.
|
||||
func Print(args ...interface{}) { |
||||
std.Print(args...) |
||||
} |
||||
|
||||
// Info logs a message at level Info on the standard logger.
|
||||
func Info(args ...interface{}) { |
||||
std.Info(args...) |
||||
} |
||||
|
||||
// Warn logs a message at level Warn on the standard logger.
|
||||
func Warn(args ...interface{}) { |
||||
std.Warn(args...) |
||||
} |
||||
|
||||
// Warning logs a message at level Warn on the standard logger.
|
||||
func Warning(args ...interface{}) { |
||||
std.Warning(args...) |
||||
} |
||||
|
||||
// Error logs a message at level Error on the standard logger.
|
||||
func Error(args ...interface{}) { |
||||
std.Error(args...) |
||||
} |
||||
|
||||
// Panic logs a message at level Panic on the standard logger.
|
||||
func Panic(args ...interface{}) { |
||||
std.Panic(args...) |
||||
} |
||||
|
||||
// Fatal logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
|
||||
func Fatal(args ...interface{}) { |
||||
std.Fatal(args...) |
||||
} |
||||
|
||||
// TraceFn logs a message from a func at level Trace on the standard logger.
|
||||
func TraceFn(fn LogFunction) { |
||||
std.TraceFn(fn) |
||||
} |
||||
|
||||
// DebugFn logs a message from a func at level Debug on the standard logger.
|
||||
func DebugFn(fn LogFunction) { |
||||
std.DebugFn(fn) |
||||
} |
||||
|
||||
// PrintFn logs a message from a func at level Info on the standard logger.
|
||||
func PrintFn(fn LogFunction) { |
||||
std.PrintFn(fn) |
||||
} |
||||
|
||||
// InfoFn logs a message from a func at level Info on the standard logger.
|
||||
func InfoFn(fn LogFunction) { |
||||
std.InfoFn(fn) |
||||
} |
||||
|
||||
// WarnFn logs a message from a func at level Warn on the standard logger.
|
||||
func WarnFn(fn LogFunction) { |
||||
std.WarnFn(fn) |
||||
} |
||||
|
||||
// WarningFn logs a message from a func at level Warn on the standard logger.
|
||||
func WarningFn(fn LogFunction) { |
||||
std.WarningFn(fn) |
||||
} |
||||
|
||||
// ErrorFn logs a message from a func at level Error on the standard logger.
|
||||
func ErrorFn(fn LogFunction) { |
||||
std.ErrorFn(fn) |
||||
} |
||||
|
||||
// PanicFn logs a message from a func at level Panic on the standard logger.
|
||||
func PanicFn(fn LogFunction) { |
||||
std.PanicFn(fn) |
||||
} |
||||
|
||||
// FatalFn logs a message from a func at level Fatal on the standard logger then the process will exit with status set to 1.
|
||||
func FatalFn(fn LogFunction) { |
||||
std.FatalFn(fn) |
||||
} |
||||
|
||||
// Tracef logs a message at level Trace on the standard logger.
|
||||
func Tracef(format string, args ...interface{}) { |
||||
std.Tracef(format, args...) |
||||
} |
||||
|
||||
// Debugf logs a message at level Debug on the standard logger.
|
||||
func Debugf(format string, args ...interface{}) { |
||||
std.Debugf(format, args...) |
||||
} |
||||
|
||||
// Printf logs a message at level Info on the standard logger.
|
||||
func Printf(format string, args ...interface{}) { |
||||
std.Printf(format, args...) |
||||
} |
||||
|
||||
// Infof logs a message at level Info on the standard logger.
|
||||
func Infof(format string, args ...interface{}) { |
||||
std.Infof(format, args...) |
||||
} |
||||
|
||||
// Warnf logs a message at level Warn on the standard logger.
|
||||
func Warnf(format string, args ...interface{}) { |
||||
std.Warnf(format, args...) |
||||
} |
||||
|
||||
// Warningf logs a message at level Warn on the standard logger.
|
||||
func Warningf(format string, args ...interface{}) { |
||||
std.Warningf(format, args...) |
||||
} |
||||
|
||||
// Errorf logs a message at level Error on the standard logger.
|
||||
func Errorf(format string, args ...interface{}) { |
||||
std.Errorf(format, args...) |
||||
} |
||||
|
||||
// Panicf logs a message at level Panic on the standard logger.
|
||||
func Panicf(format string, args ...interface{}) { |
||||
std.Panicf(format, args...) |
||||
} |
||||
|
||||
// Fatalf logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
|
||||
func Fatalf(format string, args ...interface{}) { |
||||
std.Fatalf(format, args...) |
||||
} |
||||
|
||||
// Traceln logs a message at level Trace on the standard logger.
|
||||
func Traceln(args ...interface{}) { |
||||
std.Traceln(args...) |
||||
} |
||||
|
||||
// Debugln logs a message at level Debug on the standard logger.
|
||||
func Debugln(args ...interface{}) { |
||||
std.Debugln(args...) |
||||
} |
||||
|
||||
// Println logs a message at level Info on the standard logger.
|
||||
func Println(args ...interface{}) { |
||||
std.Println(args...) |
||||
} |
||||
|
||||
// Infoln logs a message at level Info on the standard logger.
|
||||
func Infoln(args ...interface{}) { |
||||
std.Infoln(args...) |
||||
} |
||||
|
||||
// Warnln logs a message at level Warn on the standard logger.
|
||||
func Warnln(args ...interface{}) { |
||||
std.Warnln(args...) |
||||
} |
||||
|
||||
// Warningln logs a message at level Warn on the standard logger.
|
||||
func Warningln(args ...interface{}) { |
||||
std.Warningln(args...) |
||||
} |
||||
|
||||
// Errorln logs a message at level Error on the standard logger.
|
||||
func Errorln(args ...interface{}) { |
||||
std.Errorln(args...) |
||||
} |
||||
|
||||
// Panicln logs a message at level Panic on the standard logger.
|
||||
func Panicln(args ...interface{}) { |
||||
std.Panicln(args...) |
||||
} |
||||
|
||||
// Fatalln logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
|
||||
func Fatalln(args ...interface{}) { |
||||
std.Fatalln(args...) |
||||
} |
||||
@ -0,0 +1,78 @@ |
||||
package logrus |
||||
|
||||
import "time" |
||||
|
||||
// Default key names for the default fields
|
||||
const ( |
||||
defaultTimestampFormat = time.RFC3339 |
||||
FieldKeyMsg = "msg" |
||||
FieldKeyLevel = "level" |
||||
FieldKeyTime = "time" |
||||
FieldKeyLogrusError = "logrus_error" |
||||
FieldKeyFunc = "func" |
||||
FieldKeyFile = "file" |
||||
) |
||||
|
||||
// The Formatter interface is used to implement a custom Formatter. It takes an
|
||||
// `Entry`. It exposes all the fields, including the default ones:
|
||||
//
|
||||
// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
|
||||
// * `entry.Data["time"]`. The timestamp.
|
||||
// * `entry.Data["level"]. The level the entry was logged at.
|
||||
//
|
||||
// Any additional fields added with `WithField` or `WithFields` are also in
|
||||
// `entry.Data`. Format is expected to return an array of bytes which are then
|
||||
// logged to `logger.Out`.
|
||||
type Formatter interface { |
||||
Format(*Entry) ([]byte, error) |
||||
} |
||||
|
||||
// This is to not silently overwrite `time`, `msg`, `func` and `level` fields when
|
||||
// dumping it. If this code wasn't there doing:
|
||||
//
|
||||
// logrus.WithField("level", 1).Info("hello")
|
||||
//
|
||||
// Would just silently drop the user provided level. Instead with this code
|
||||
// it'll logged as:
|
||||
//
|
||||
// {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
|
||||
//
|
||||
// It's not exported because it's still using Data in an opinionated way. It's to
|
||||
// avoid code duplication between the two default formatters.
|
||||
func prefixFieldClashes(data Fields, fieldMap FieldMap, reportCaller bool) { |
||||
timeKey := fieldMap.resolve(FieldKeyTime) |
||||
if t, ok := data[timeKey]; ok { |
||||
data["fields."+timeKey] = t |
||||
delete(data, timeKey) |
||||
} |
||||
|
||||
msgKey := fieldMap.resolve(FieldKeyMsg) |
||||
if m, ok := data[msgKey]; ok { |
||||
data["fields."+msgKey] = m |
||||
delete(data, msgKey) |
||||
} |
||||
|
||||
levelKey := fieldMap.resolve(FieldKeyLevel) |
||||
if l, ok := data[levelKey]; ok { |
||||
data["fields."+levelKey] = l |
||||
delete(data, levelKey) |
||||
} |
||||
|
||||
logrusErrKey := fieldMap.resolve(FieldKeyLogrusError) |
||||
if l, ok := data[logrusErrKey]; ok { |
||||
data["fields."+logrusErrKey] = l |
||||
delete(data, logrusErrKey) |
||||
} |
||||
|
||||
// If reportCaller is not set, 'func' will not conflict.
|
||||
if reportCaller { |
||||
funcKey := fieldMap.resolve(FieldKeyFunc) |
||||
if l, ok := data[funcKey]; ok { |
||||
data["fields."+funcKey] = l |
||||
} |
||||
fileKey := fieldMap.resolve(FieldKeyFile) |
||||
if l, ok := data[fileKey]; ok { |
||||
data["fields."+fileKey] = l |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,34 @@ |
||||
package logrus |
||||
|
||||
// A hook to be fired when logging on the logging levels returned from
|
||||
// `Levels()` on your implementation of the interface. Note that this is not
|
||||
// fired in a goroutine or a channel with workers, you should handle such
|
||||
// functionality yourself if your call is non-blocking and you don't wish for
|
||||
// the logging calls for levels returned from `Levels()` to block.
|
||||
type Hook interface { |
||||
Levels() []Level |
||||
Fire(*Entry) error |
||||
} |
||||
|
||||
// Internal type for storing the hooks on a logger instance.
|
||||
type LevelHooks map[Level][]Hook |
||||
|
||||
// Add a hook to an instance of logger. This is called with
|
||||
// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
|
||||
func (hooks LevelHooks) Add(hook Hook) { |
||||
for _, level := range hook.Levels() { |
||||
hooks[level] = append(hooks[level], hook) |
||||
} |
||||
} |
||||
|
||||
// Fire all the hooks for the passed level. Used by `entry.log` to fire
|
||||
// appropriate hooks for a log entry.
|
||||
func (hooks LevelHooks) Fire(level Level, entry *Entry) error { |
||||
for _, hook := range hooks[level] { |
||||
if err := hook.Fire(entry); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
@ -0,0 +1,128 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/json" |
||||
"fmt" |
||||
"runtime" |
||||
) |
||||
|
||||
type fieldKey string |
||||
|
||||
// FieldMap allows customization of the key names for default fields.
|
||||
type FieldMap map[fieldKey]string |
||||
|
||||
func (f FieldMap) resolve(key fieldKey) string { |
||||
if k, ok := f[key]; ok { |
||||
return k |
||||
} |
||||
|
||||
return string(key) |
||||
} |
||||
|
||||
// JSONFormatter formats logs into parsable json
|
||||
type JSONFormatter struct { |
||||
// TimestampFormat sets the format used for marshaling timestamps.
|
||||
// The format to use is the same than for time.Format or time.Parse from the standard
|
||||
// library.
|
||||
// The standard Library already provides a set of predefined format.
|
||||
TimestampFormat string |
||||
|
||||
// DisableTimestamp allows disabling automatic timestamps in output
|
||||
DisableTimestamp bool |
||||
|
||||
// DisableHTMLEscape allows disabling html escaping in output
|
||||
DisableHTMLEscape bool |
||||
|
||||
// DataKey allows users to put all the log entry parameters into a nested dictionary at a given key.
|
||||
DataKey string |
||||
|
||||
// FieldMap allows users to customize the names of keys for default fields.
|
||||
// As an example:
|
||||
// formatter := &JSONFormatter{
|
||||
// FieldMap: FieldMap{
|
||||
// FieldKeyTime: "@timestamp",
|
||||
// FieldKeyLevel: "@level",
|
||||
// FieldKeyMsg: "@message",
|
||||
// FieldKeyFunc: "@caller",
|
||||
// },
|
||||
// }
|
||||
FieldMap FieldMap |
||||
|
||||
// CallerPrettyfier can be set by the user to modify the content
|
||||
// of the function and file keys in the json data when ReportCaller is
|
||||
// activated. If any of the returned value is the empty string the
|
||||
// corresponding key will be removed from json fields.
|
||||
CallerPrettyfier func(*runtime.Frame) (function string, file string) |
||||
|
||||
// PrettyPrint will indent all json logs
|
||||
PrettyPrint bool |
||||
} |
||||
|
||||
// Format renders a single log entry
|
||||
func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) { |
||||
data := make(Fields, len(entry.Data)+4) |
||||
for k, v := range entry.Data { |
||||
switch v := v.(type) { |
||||
case error: |
||||
// Otherwise errors are ignored by `encoding/json`
|
||||
// https://github.com/sirupsen/logrus/issues/137
|
||||
data[k] = v.Error() |
||||
default: |
||||
data[k] = v |
||||
} |
||||
} |
||||
|
||||
if f.DataKey != "" { |
||||
newData := make(Fields, 4) |
||||
newData[f.DataKey] = data |
||||
data = newData |
||||
} |
||||
|
||||
prefixFieldClashes(data, f.FieldMap, entry.HasCaller()) |
||||
|
||||
timestampFormat := f.TimestampFormat |
||||
if timestampFormat == "" { |
||||
timestampFormat = defaultTimestampFormat |
||||
} |
||||
|
||||
if entry.err != "" { |
||||
data[f.FieldMap.resolve(FieldKeyLogrusError)] = entry.err |
||||
} |
||||
if !f.DisableTimestamp { |
||||
data[f.FieldMap.resolve(FieldKeyTime)] = entry.Time.Format(timestampFormat) |
||||
} |
||||
data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message |
||||
data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String() |
||||
if entry.HasCaller() { |
||||
funcVal := entry.Caller.Function |
||||
fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line) |
||||
if f.CallerPrettyfier != nil { |
||||
funcVal, fileVal = f.CallerPrettyfier(entry.Caller) |
||||
} |
||||
if funcVal != "" { |
||||
data[f.FieldMap.resolve(FieldKeyFunc)] = funcVal |
||||
} |
||||
if fileVal != "" { |
||||
data[f.FieldMap.resolve(FieldKeyFile)] = fileVal |
||||
} |
||||
} |
||||
|
||||
var b *bytes.Buffer |
||||
if entry.Buffer != nil { |
||||
b = entry.Buffer |
||||
} else { |
||||
b = &bytes.Buffer{} |
||||
} |
||||
|
||||
encoder := json.NewEncoder(b) |
||||
encoder.SetEscapeHTML(!f.DisableHTMLEscape) |
||||
if f.PrettyPrint { |
||||
encoder.SetIndent("", " ") |
||||
} |
||||
if err := encoder.Encode(data); err != nil { |
||||
return nil, fmt.Errorf("failed to marshal fields to JSON, %w", err) |
||||
} |
||||
|
||||
return b.Bytes(), nil |
||||
} |
||||
@ -0,0 +1,417 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"context" |
||||
"io" |
||||
"os" |
||||
"sync" |
||||
"sync/atomic" |
||||
"time" |
||||
) |
||||
|
||||
// LogFunction For big messages, it can be more efficient to pass a function
|
||||
// and only call it if the log level is actually enables rather than
|
||||
// generating the log message and then checking if the level is enabled
|
||||
type LogFunction func() []interface{} |
||||
|
||||
type Logger struct { |
||||
// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
|
||||
// file, or leave it default which is `os.Stderr`. You can also set this to
|
||||
// something more adventurous, such as logging to Kafka.
|
||||
Out io.Writer |
||||
// Hooks for the logger instance. These allow firing events based on logging
|
||||
// levels and log entries. For example, to send errors to an error tracking
|
||||
// service, log to StatsD or dump the core on fatal errors.
|
||||
Hooks LevelHooks |
||||
// All log entries pass through the formatter before logged to Out. The
|
||||
// included formatters are `TextFormatter` and `JSONFormatter` for which
|
||||
// TextFormatter is the default. In development (when a TTY is attached) it
|
||||
// logs with colors, but to a file it wouldn't. You can easily implement your
|
||||
// own that implements the `Formatter` interface, see the `README` or included
|
||||
// formatters for examples.
|
||||
Formatter Formatter |
||||
|
||||
// Flag for whether to log caller info (off by default)
|
||||
ReportCaller bool |
||||
|
||||
// The logging level the logger should log at. This is typically (and defaults
|
||||
// to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
|
||||
// logged.
|
||||
Level Level |
||||
// Used to sync writing to the log. Locking is enabled by Default
|
||||
mu MutexWrap |
||||
// Reusable empty entry
|
||||
entryPool sync.Pool |
||||
// Function to exit the application, defaults to `os.Exit()`
|
||||
ExitFunc exitFunc |
||||
// The buffer pool used to format the log. If it is nil, the default global
|
||||
// buffer pool will be used.
|
||||
BufferPool BufferPool |
||||
} |
||||
|
||||
type exitFunc func(int) |
||||
|
||||
type MutexWrap struct { |
||||
lock sync.Mutex |
||||
disabled bool |
||||
} |
||||
|
||||
func (mw *MutexWrap) Lock() { |
||||
if !mw.disabled { |
||||
mw.lock.Lock() |
||||
} |
||||
} |
||||
|
||||
func (mw *MutexWrap) Unlock() { |
||||
if !mw.disabled { |
||||
mw.lock.Unlock() |
||||
} |
||||
} |
||||
|
||||
func (mw *MutexWrap) Disable() { |
||||
mw.disabled = true |
||||
} |
||||
|
||||
// Creates a new logger. Configuration should be set by changing `Formatter`,
|
||||
// `Out` and `Hooks` directly on the default logger instance. You can also just
|
||||
// instantiate your own:
|
||||
//
|
||||
// var log = &logrus.Logger{
|
||||
// Out: os.Stderr,
|
||||
// Formatter: new(logrus.TextFormatter),
|
||||
// Hooks: make(logrus.LevelHooks),
|
||||
// Level: logrus.DebugLevel,
|
||||
// }
|
||||
//
|
||||
// It's recommended to make this a global instance called `log`.
|
||||
func New() *Logger { |
||||
return &Logger{ |
||||
Out: os.Stderr, |
||||
Formatter: new(TextFormatter), |
||||
Hooks: make(LevelHooks), |
||||
Level: InfoLevel, |
||||
ExitFunc: os.Exit, |
||||
ReportCaller: false, |
||||
} |
||||
} |
||||
|
||||
func (logger *Logger) newEntry() *Entry { |
||||
entry, ok := logger.entryPool.Get().(*Entry) |
||||
if ok { |
||||
return entry |
||||
} |
||||
return NewEntry(logger) |
||||
} |
||||
|
||||
func (logger *Logger) releaseEntry(entry *Entry) { |
||||
entry.Data = map[string]interface{}{} |
||||
logger.entryPool.Put(entry) |
||||
} |
||||
|
||||
// WithField allocates a new entry and adds a field to it.
|
||||
// Debug, Print, Info, Warn, Error, Fatal or Panic must be then applied to
|
||||
// this new returned entry.
|
||||
// If you want multiple fields, use `WithFields`.
|
||||
func (logger *Logger) WithField(key string, value interface{}) *Entry { |
||||
entry := logger.newEntry() |
||||
defer logger.releaseEntry(entry) |
||||
return entry.WithField(key, value) |
||||
} |
||||
|
||||
// Adds a struct of fields to the log entry. All it does is call `WithField` for
|
||||
// each `Field`.
|
||||
func (logger *Logger) WithFields(fields Fields) *Entry { |
||||
entry := logger.newEntry() |
||||
defer logger.releaseEntry(entry) |
||||
return entry.WithFields(fields) |
||||
} |
||||
|
||||
// Add an error as single field to the log entry. All it does is call
|
||||
// `WithError` for the given `error`.
|
||||
func (logger *Logger) WithError(err error) *Entry { |
||||
entry := logger.newEntry() |
||||
defer logger.releaseEntry(entry) |
||||
return entry.WithError(err) |
||||
} |
||||
|
||||
// Add a context to the log entry.
|
||||
func (logger *Logger) WithContext(ctx context.Context) *Entry { |
||||
entry := logger.newEntry() |
||||
defer logger.releaseEntry(entry) |
||||
return entry.WithContext(ctx) |
||||
} |
||||
|
||||
// Overrides the time of the log entry.
|
||||
func (logger *Logger) WithTime(t time.Time) *Entry { |
||||
entry := logger.newEntry() |
||||
defer logger.releaseEntry(entry) |
||||
return entry.WithTime(t) |
||||
} |
||||
|
||||
func (logger *Logger) Logf(level Level, format string, args ...interface{}) { |
||||
if logger.IsLevelEnabled(level) { |
||||
entry := logger.newEntry() |
||||
entry.Logf(level, format, args...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
} |
||||
|
||||
func (logger *Logger) Tracef(format string, args ...interface{}) { |
||||
logger.Logf(TraceLevel, format, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Debugf(format string, args ...interface{}) { |
||||
logger.Logf(DebugLevel, format, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Infof(format string, args ...interface{}) { |
||||
logger.Logf(InfoLevel, format, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Printf(format string, args ...interface{}) { |
||||
entry := logger.newEntry() |
||||
entry.Printf(format, args...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
|
||||
func (logger *Logger) Warnf(format string, args ...interface{}) { |
||||
logger.Logf(WarnLevel, format, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Warningf(format string, args ...interface{}) { |
||||
logger.Warnf(format, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Errorf(format string, args ...interface{}) { |
||||
logger.Logf(ErrorLevel, format, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Fatalf(format string, args ...interface{}) { |
||||
logger.Logf(FatalLevel, format, args...) |
||||
logger.Exit(1) |
||||
} |
||||
|
||||
func (logger *Logger) Panicf(format string, args ...interface{}) { |
||||
logger.Logf(PanicLevel, format, args...) |
||||
} |
||||
|
||||
// Log will log a message at the level given as parameter.
|
||||
// Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
|
||||
// For this behaviour Logger.Panic or Logger.Fatal should be used instead.
|
||||
func (logger *Logger) Log(level Level, args ...interface{}) { |
||||
if logger.IsLevelEnabled(level) { |
||||
entry := logger.newEntry() |
||||
entry.Log(level, args...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
} |
||||
|
||||
func (logger *Logger) LogFn(level Level, fn LogFunction) { |
||||
if logger.IsLevelEnabled(level) { |
||||
entry := logger.newEntry() |
||||
entry.Log(level, fn()...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
} |
||||
|
||||
func (logger *Logger) Trace(args ...interface{}) { |
||||
logger.Log(TraceLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Debug(args ...interface{}) { |
||||
logger.Log(DebugLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Info(args ...interface{}) { |
||||
logger.Log(InfoLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Print(args ...interface{}) { |
||||
entry := logger.newEntry() |
||||
entry.Print(args...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
|
||||
func (logger *Logger) Warn(args ...interface{}) { |
||||
logger.Log(WarnLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Warning(args ...interface{}) { |
||||
logger.Warn(args...) |
||||
} |
||||
|
||||
func (logger *Logger) Error(args ...interface{}) { |
||||
logger.Log(ErrorLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Fatal(args ...interface{}) { |
||||
logger.Log(FatalLevel, args...) |
||||
logger.Exit(1) |
||||
} |
||||
|
||||
func (logger *Logger) Panic(args ...interface{}) { |
||||
logger.Log(PanicLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) TraceFn(fn LogFunction) { |
||||
logger.LogFn(TraceLevel, fn) |
||||
} |
||||
|
||||
func (logger *Logger) DebugFn(fn LogFunction) { |
||||
logger.LogFn(DebugLevel, fn) |
||||
} |
||||
|
||||
func (logger *Logger) InfoFn(fn LogFunction) { |
||||
logger.LogFn(InfoLevel, fn) |
||||
} |
||||
|
||||
func (logger *Logger) PrintFn(fn LogFunction) { |
||||
entry := logger.newEntry() |
||||
entry.Print(fn()...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
|
||||
func (logger *Logger) WarnFn(fn LogFunction) { |
||||
logger.LogFn(WarnLevel, fn) |
||||
} |
||||
|
||||
func (logger *Logger) WarningFn(fn LogFunction) { |
||||
logger.WarnFn(fn) |
||||
} |
||||
|
||||
func (logger *Logger) ErrorFn(fn LogFunction) { |
||||
logger.LogFn(ErrorLevel, fn) |
||||
} |
||||
|
||||
func (logger *Logger) FatalFn(fn LogFunction) { |
||||
logger.LogFn(FatalLevel, fn) |
||||
logger.Exit(1) |
||||
} |
||||
|
||||
func (logger *Logger) PanicFn(fn LogFunction) { |
||||
logger.LogFn(PanicLevel, fn) |
||||
} |
||||
|
||||
func (logger *Logger) Logln(level Level, args ...interface{}) { |
||||
if logger.IsLevelEnabled(level) { |
||||
entry := logger.newEntry() |
||||
entry.Logln(level, args...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
} |
||||
|
||||
func (logger *Logger) Traceln(args ...interface{}) { |
||||
logger.Logln(TraceLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Debugln(args ...interface{}) { |
||||
logger.Logln(DebugLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Infoln(args ...interface{}) { |
||||
logger.Logln(InfoLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Println(args ...interface{}) { |
||||
entry := logger.newEntry() |
||||
entry.Println(args...) |
||||
logger.releaseEntry(entry) |
||||
} |
||||
|
||||
func (logger *Logger) Warnln(args ...interface{}) { |
||||
logger.Logln(WarnLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Warningln(args ...interface{}) { |
||||
logger.Warnln(args...) |
||||
} |
||||
|
||||
func (logger *Logger) Errorln(args ...interface{}) { |
||||
logger.Logln(ErrorLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Fatalln(args ...interface{}) { |
||||
logger.Logln(FatalLevel, args...) |
||||
logger.Exit(1) |
||||
} |
||||
|
||||
func (logger *Logger) Panicln(args ...interface{}) { |
||||
logger.Logln(PanicLevel, args...) |
||||
} |
||||
|
||||
func (logger *Logger) Exit(code int) { |
||||
runHandlers() |
||||
if logger.ExitFunc == nil { |
||||
logger.ExitFunc = os.Exit |
||||
} |
||||
logger.ExitFunc(code) |
||||
} |
||||
|
||||
//When file is opened with appending mode, it's safe to
|
||||
//write concurrently to a file (within 4k message on Linux).
|
||||
//In these cases user can choose to disable the lock.
|
||||
func (logger *Logger) SetNoLock() { |
||||
logger.mu.Disable() |
||||
} |
||||
|
||||
func (logger *Logger) level() Level { |
||||
return Level(atomic.LoadUint32((*uint32)(&logger.Level))) |
||||
} |
||||
|
||||
// SetLevel sets the logger level.
|
||||
func (logger *Logger) SetLevel(level Level) { |
||||
atomic.StoreUint32((*uint32)(&logger.Level), uint32(level)) |
||||
} |
||||
|
||||
// GetLevel returns the logger level.
|
||||
func (logger *Logger) GetLevel() Level { |
||||
return logger.level() |
||||
} |
||||
|
||||
// AddHook adds a hook to the logger hooks.
|
||||
func (logger *Logger) AddHook(hook Hook) { |
||||
logger.mu.Lock() |
||||
defer logger.mu.Unlock() |
||||
logger.Hooks.Add(hook) |
||||
} |
||||
|
||||
// IsLevelEnabled checks if the log level of the logger is greater than the level param
|
||||
func (logger *Logger) IsLevelEnabled(level Level) bool { |
||||
return logger.level() >= level |
||||
} |
||||
|
||||
// SetFormatter sets the logger formatter.
|
||||
func (logger *Logger) SetFormatter(formatter Formatter) { |
||||
logger.mu.Lock() |
||||
defer logger.mu.Unlock() |
||||
logger.Formatter = formatter |
||||
} |
||||
|
||||
// SetOutput sets the logger output.
|
||||
func (logger *Logger) SetOutput(output io.Writer) { |
||||
logger.mu.Lock() |
||||
defer logger.mu.Unlock() |
||||
logger.Out = output |
||||
} |
||||
|
||||
func (logger *Logger) SetReportCaller(reportCaller bool) { |
||||
logger.mu.Lock() |
||||
defer logger.mu.Unlock() |
||||
logger.ReportCaller = reportCaller |
||||
} |
||||
|
||||
// ReplaceHooks replaces the logger hooks and returns the old ones
|
||||
func (logger *Logger) ReplaceHooks(hooks LevelHooks) LevelHooks { |
||||
logger.mu.Lock() |
||||
oldHooks := logger.Hooks |
||||
logger.Hooks = hooks |
||||
logger.mu.Unlock() |
||||
return oldHooks |
||||
} |
||||
|
||||
// SetBufferPool sets the logger buffer pool.
|
||||
func (logger *Logger) SetBufferPool(pool BufferPool) { |
||||
logger.mu.Lock() |
||||
defer logger.mu.Unlock() |
||||
logger.BufferPool = pool |
||||
} |
||||
@ -0,0 +1,186 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"fmt" |
||||
"log" |
||||
"strings" |
||||
) |
||||
|
||||
// Fields type, used to pass to `WithFields`.
|
||||
type Fields map[string]interface{} |
||||
|
||||
// Level type
|
||||
type Level uint32 |
||||
|
||||
// Convert the Level to a string. E.g. PanicLevel becomes "panic".
|
||||
func (level Level) String() string { |
||||
if b, err := level.MarshalText(); err == nil { |
||||
return string(b) |
||||
} else { |
||||
return "unknown" |
||||
} |
||||
} |
||||
|
||||
// ParseLevel takes a string level and returns the Logrus log level constant.
|
||||
func ParseLevel(lvl string) (Level, error) { |
||||
switch strings.ToLower(lvl) { |
||||
case "panic": |
||||
return PanicLevel, nil |
||||
case "fatal": |
||||
return FatalLevel, nil |
||||
case "error": |
||||
return ErrorLevel, nil |
||||
case "warn", "warning": |
||||
return WarnLevel, nil |
||||
case "info": |
||||
return InfoLevel, nil |
||||
case "debug": |
||||
return DebugLevel, nil |
||||
case "trace": |
||||
return TraceLevel, nil |
||||
} |
||||
|
||||
var l Level |
||||
return l, fmt.Errorf("not a valid logrus Level: %q", lvl) |
||||
} |
||||
|
||||
// UnmarshalText implements encoding.TextUnmarshaler.
|
||||
func (level *Level) UnmarshalText(text []byte) error { |
||||
l, err := ParseLevel(string(text)) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
*level = l |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (level Level) MarshalText() ([]byte, error) { |
||||
switch level { |
||||
case TraceLevel: |
||||
return []byte("trace"), nil |
||||
case DebugLevel: |
||||
return []byte("debug"), nil |
||||
case InfoLevel: |
||||
return []byte("info"), nil |
||||
case WarnLevel: |
||||
return []byte("warning"), nil |
||||
case ErrorLevel: |
||||
return []byte("error"), nil |
||||
case FatalLevel: |
||||
return []byte("fatal"), nil |
||||
case PanicLevel: |
||||
return []byte("panic"), nil |
||||
} |
||||
|
||||
return nil, fmt.Errorf("not a valid logrus level %d", level) |
||||
} |
||||
|
||||
// A constant exposing all logging levels
|
||||
var AllLevels = []Level{ |
||||
PanicLevel, |
||||
FatalLevel, |
||||
ErrorLevel, |
||||
WarnLevel, |
||||
InfoLevel, |
||||
DebugLevel, |
||||
TraceLevel, |
||||
} |
||||
|
||||
// These are the different logging levels. You can set the logging level to log
|
||||
// on your instance of logger, obtained with `logrus.New()`.
|
||||
const ( |
||||
// PanicLevel level, highest level of severity. Logs and then calls panic with the
|
||||
// message passed to Debug, Info, ...
|
||||
PanicLevel Level = iota |
||||
// FatalLevel level. Logs and then calls `logger.Exit(1)`. It will exit even if the
|
||||
// logging level is set to Panic.
|
||||
FatalLevel |
||||
// ErrorLevel level. Logs. Used for errors that should definitely be noted.
|
||||
// Commonly used for hooks to send errors to an error tracking service.
|
||||
ErrorLevel |
||||
// WarnLevel level. Non-critical entries that deserve eyes.
|
||||
WarnLevel |
||||
// InfoLevel level. General operational entries about what's going on inside the
|
||||
// application.
|
||||
InfoLevel |
||||
// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
|
||||
DebugLevel |
||||
// TraceLevel level. Designates finer-grained informational events than the Debug.
|
||||
TraceLevel |
||||
) |
||||
|
||||
// Won't compile if StdLogger can't be realized by a log.Logger
|
||||
var ( |
||||
_ StdLogger = &log.Logger{} |
||||
_ StdLogger = &Entry{} |
||||
_ StdLogger = &Logger{} |
||||
) |
||||
|
||||
// StdLogger is what your logrus-enabled library should take, that way
|
||||
// it'll accept a stdlib logger and a logrus logger. There's no standard
|
||||
// interface, this is the closest we get, unfortunately.
|
||||
type StdLogger interface { |
||||
Print(...interface{}) |
||||
Printf(string, ...interface{}) |
||||
Println(...interface{}) |
||||
|
||||
Fatal(...interface{}) |
||||
Fatalf(string, ...interface{}) |
||||
Fatalln(...interface{}) |
||||
|
||||
Panic(...interface{}) |
||||
Panicf(string, ...interface{}) |
||||
Panicln(...interface{}) |
||||
} |
||||
|
||||
// The FieldLogger interface generalizes the Entry and Logger types
|
||||
type FieldLogger interface { |
||||
WithField(key string, value interface{}) *Entry |
||||
WithFields(fields Fields) *Entry |
||||
WithError(err error) *Entry |
||||
|
||||
Debugf(format string, args ...interface{}) |
||||
Infof(format string, args ...interface{}) |
||||
Printf(format string, args ...interface{}) |
||||
Warnf(format string, args ...interface{}) |
||||
Warningf(format string, args ...interface{}) |
||||
Errorf(format string, args ...interface{}) |
||||
Fatalf(format string, args ...interface{}) |
||||
Panicf(format string, args ...interface{}) |
||||
|
||||
Debug(args ...interface{}) |
||||
Info(args ...interface{}) |
||||
Print(args ...interface{}) |
||||
Warn(args ...interface{}) |
||||
Warning(args ...interface{}) |
||||
Error(args ...interface{}) |
||||
Fatal(args ...interface{}) |
||||
Panic(args ...interface{}) |
||||
|
||||
Debugln(args ...interface{}) |
||||
Infoln(args ...interface{}) |
||||
Println(args ...interface{}) |
||||
Warnln(args ...interface{}) |
||||
Warningln(args ...interface{}) |
||||
Errorln(args ...interface{}) |
||||
Fatalln(args ...interface{}) |
||||
Panicln(args ...interface{}) |
||||
|
||||
// IsDebugEnabled() bool
|
||||
// IsInfoEnabled() bool
|
||||
// IsWarnEnabled() bool
|
||||
// IsErrorEnabled() bool
|
||||
// IsFatalEnabled() bool
|
||||
// IsPanicEnabled() bool
|
||||
} |
||||
|
||||
// Ext1FieldLogger (the first extension to FieldLogger) is superfluous, it is
|
||||
// here for consistancy. Do not use. Use Logger or Entry instead.
|
||||
type Ext1FieldLogger interface { |
||||
FieldLogger |
||||
Tracef(format string, args ...interface{}) |
||||
Trace(args ...interface{}) |
||||
Traceln(args ...interface{}) |
||||
} |
||||
@ -0,0 +1,11 @@ |
||||
// +build appengine
|
||||
|
||||
package logrus |
||||
|
||||
import ( |
||||
"io" |
||||
) |
||||
|
||||
func checkIfTerminal(w io.Writer) bool { |
||||
return true |
||||
} |
||||
@ -0,0 +1,13 @@ |
||||
// +build darwin dragonfly freebsd netbsd openbsd
|
||||
// +build !js
|
||||
|
||||
package logrus |
||||
|
||||
import "golang.org/x/sys/unix" |
||||
|
||||
const ioctlReadTermios = unix.TIOCGETA |
||||
|
||||
func isTerminal(fd int) bool { |
||||
_, err := unix.IoctlGetTermios(fd, ioctlReadTermios) |
||||
return err == nil |
||||
} |
||||
@ -0,0 +1,7 @@ |
||||
// +build js
|
||||
|
||||
package logrus |
||||
|
||||
func isTerminal(fd int) bool { |
||||
return false |
||||
} |
||||
@ -0,0 +1,11 @@ |
||||
// +build js nacl plan9
|
||||
|
||||
package logrus |
||||
|
||||
import ( |
||||
"io" |
||||
) |
||||
|
||||
func checkIfTerminal(w io.Writer) bool { |
||||
return false |
||||
} |
||||
@ -0,0 +1,17 @@ |
||||
// +build !appengine,!js,!windows,!nacl,!plan9
|
||||
|
||||
package logrus |
||||
|
||||
import ( |
||||
"io" |
||||
"os" |
||||
) |
||||
|
||||
func checkIfTerminal(w io.Writer) bool { |
||||
switch v := w.(type) { |
||||
case *os.File: |
||||
return isTerminal(int(v.Fd())) |
||||
default: |
||||
return false |
||||
} |
||||
} |
||||
@ -0,0 +1,11 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"golang.org/x/sys/unix" |
||||
) |
||||
|
||||
// IsTerminal returns true if the given file descriptor is a terminal.
|
||||
func isTerminal(fd int) bool { |
||||
_, err := unix.IoctlGetTermio(fd, unix.TCGETA) |
||||
return err == nil |
||||
} |
||||
@ -0,0 +1,13 @@ |
||||
// +build linux aix zos
|
||||
// +build !js
|
||||
|
||||
package logrus |
||||
|
||||
import "golang.org/x/sys/unix" |
||||
|
||||
const ioctlReadTermios = unix.TCGETS |
||||
|
||||
func isTerminal(fd int) bool { |
||||
_, err := unix.IoctlGetTermios(fd, ioctlReadTermios) |
||||
return err == nil |
||||
} |
||||
@ -0,0 +1,27 @@ |
||||
// +build !appengine,!js,windows
|
||||
|
||||
package logrus |
||||
|
||||
import ( |
||||
"io" |
||||
"os" |
||||
|
||||
"golang.org/x/sys/windows" |
||||
) |
||||
|
||||
func checkIfTerminal(w io.Writer) bool { |
||||
switch v := w.(type) { |
||||
case *os.File: |
||||
handle := windows.Handle(v.Fd()) |
||||
var mode uint32 |
||||
if err := windows.GetConsoleMode(handle, &mode); err != nil { |
||||
return false |
||||
} |
||||
mode |= windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING |
||||
if err := windows.SetConsoleMode(handle, mode); err != nil { |
||||
return false |
||||
} |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
@ -0,0 +1,339 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"os" |
||||
"runtime" |
||||
"sort" |
||||
"strconv" |
||||
"strings" |
||||
"sync" |
||||
"time" |
||||
"unicode/utf8" |
||||
) |
||||
|
||||
const ( |
||||
red = 31 |
||||
yellow = 33 |
||||
blue = 36 |
||||
gray = 37 |
||||
) |
||||
|
||||
var baseTimestamp time.Time |
||||
|
||||
func init() { |
||||
baseTimestamp = time.Now() |
||||
} |
||||
|
||||
// TextFormatter formats logs into text
|
||||
type TextFormatter struct { |
||||
// Set to true to bypass checking for a TTY before outputting colors.
|
||||
ForceColors bool |
||||
|
||||
// Force disabling colors.
|
||||
DisableColors bool |
||||
|
||||
// Force quoting of all values
|
||||
ForceQuote bool |
||||
|
||||
// DisableQuote disables quoting for all values.
|
||||
// DisableQuote will have a lower priority than ForceQuote.
|
||||
// If both of them are set to true, quote will be forced on all values.
|
||||
DisableQuote bool |
||||
|
||||
// Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
|
||||
EnvironmentOverrideColors bool |
||||
|
||||
// Disable timestamp logging. useful when output is redirected to logging
|
||||
// system that already adds timestamps.
|
||||
DisableTimestamp bool |
||||
|
||||
// Enable logging the full timestamp when a TTY is attached instead of just
|
||||
// the time passed since beginning of execution.
|
||||
FullTimestamp bool |
||||
|
||||
// TimestampFormat to use for display when a full timestamp is printed.
|
||||
// The format to use is the same than for time.Format or time.Parse from the standard
|
||||
// library.
|
||||
// The standard Library already provides a set of predefined format.
|
||||
TimestampFormat string |
||||
|
||||
// The fields are sorted by default for a consistent output. For applications
|
||||
// that log extremely frequently and don't use the JSON formatter this may not
|
||||
// be desired.
|
||||
DisableSorting bool |
||||
|
||||
// The keys sorting function, when uninitialized it uses sort.Strings.
|
||||
SortingFunc func([]string) |
||||
|
||||
// Disables the truncation of the level text to 4 characters.
|
||||
DisableLevelTruncation bool |
||||
|
||||
// PadLevelText Adds padding the level text so that all the levels output at the same length
|
||||
// PadLevelText is a superset of the DisableLevelTruncation option
|
||||
PadLevelText bool |
||||
|
||||
// QuoteEmptyFields will wrap empty fields in quotes if true
|
||||
QuoteEmptyFields bool |
||||
|
||||
// Whether the logger's out is to a terminal
|
||||
isTerminal bool |
||||
|
||||
// FieldMap allows users to customize the names of keys for default fields.
|
||||
// As an example:
|
||||
// formatter := &TextFormatter{
|
||||
// FieldMap: FieldMap{
|
||||
// FieldKeyTime: "@timestamp",
|
||||
// FieldKeyLevel: "@level",
|
||||
// FieldKeyMsg: "@message"}}
|
||||
FieldMap FieldMap |
||||
|
||||
// CallerPrettyfier can be set by the user to modify the content
|
||||
// of the function and file keys in the data when ReportCaller is
|
||||
// activated. If any of the returned value is the empty string the
|
||||
// corresponding key will be removed from fields.
|
||||
CallerPrettyfier func(*runtime.Frame) (function string, file string) |
||||
|
||||
terminalInitOnce sync.Once |
||||
|
||||
// The max length of the level text, generated dynamically on init
|
||||
levelTextMaxLength int |
||||
} |
||||
|
||||
func (f *TextFormatter) init(entry *Entry) { |
||||
if entry.Logger != nil { |
||||
f.isTerminal = checkIfTerminal(entry.Logger.Out) |
||||
} |
||||
// Get the max length of the level text
|
||||
for _, level := range AllLevels { |
||||
levelTextLength := utf8.RuneCount([]byte(level.String())) |
||||
if levelTextLength > f.levelTextMaxLength { |
||||
f.levelTextMaxLength = levelTextLength |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (f *TextFormatter) isColored() bool { |
||||
isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows")) |
||||
|
||||
if f.EnvironmentOverrideColors { |
||||
switch force, ok := os.LookupEnv("CLICOLOR_FORCE"); { |
||||
case ok && force != "0": |
||||
isColored = true |
||||
case ok && force == "0", os.Getenv("CLICOLOR") == "0": |
||||
isColored = false |
||||
} |
||||
} |
||||
|
||||
return isColored && !f.DisableColors |
||||
} |
||||
|
||||
// Format renders a single log entry
|
||||
func (f *TextFormatter) Format(entry *Entry) ([]byte, error) { |
||||
data := make(Fields) |
||||
for k, v := range entry.Data { |
||||
data[k] = v |
||||
} |
||||
prefixFieldClashes(data, f.FieldMap, entry.HasCaller()) |
||||
keys := make([]string, 0, len(data)) |
||||
for k := range data { |
||||
keys = append(keys, k) |
||||
} |
||||
|
||||
var funcVal, fileVal string |
||||
|
||||
fixedKeys := make([]string, 0, 4+len(data)) |
||||
if !f.DisableTimestamp { |
||||
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime)) |
||||
} |
||||
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel)) |
||||
if entry.Message != "" { |
||||
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg)) |
||||
} |
||||
if entry.err != "" { |
||||
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError)) |
||||
} |
||||
if entry.HasCaller() { |
||||
if f.CallerPrettyfier != nil { |
||||
funcVal, fileVal = f.CallerPrettyfier(entry.Caller) |
||||
} else { |
||||
funcVal = entry.Caller.Function |
||||
fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line) |
||||
} |
||||
|
||||
if funcVal != "" { |
||||
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc)) |
||||
} |
||||
if fileVal != "" { |
||||
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile)) |
||||
} |
||||
} |
||||
|
||||
if !f.DisableSorting { |
||||
if f.SortingFunc == nil { |
||||
sort.Strings(keys) |
||||
fixedKeys = append(fixedKeys, keys...) |
||||
} else { |
||||
if !f.isColored() { |
||||
fixedKeys = append(fixedKeys, keys...) |
||||
f.SortingFunc(fixedKeys) |
||||
} else { |
||||
f.SortingFunc(keys) |
||||
} |
||||
} |
||||
} else { |
||||
fixedKeys = append(fixedKeys, keys...) |
||||
} |
||||
|
||||
var b *bytes.Buffer |
||||
if entry.Buffer != nil { |
||||
b = entry.Buffer |
||||
} else { |
||||
b = &bytes.Buffer{} |
||||
} |
||||
|
||||
f.terminalInitOnce.Do(func() { f.init(entry) }) |
||||
|
||||
timestampFormat := f.TimestampFormat |
||||
if timestampFormat == "" { |
||||
timestampFormat = defaultTimestampFormat |
||||
} |
||||
if f.isColored() { |
||||
f.printColored(b, entry, keys, data, timestampFormat) |
||||
} else { |
||||
|
||||
for _, key := range fixedKeys { |
||||
var value interface{} |
||||
switch { |
||||
case key == f.FieldMap.resolve(FieldKeyTime): |
||||
value = entry.Time.Format(timestampFormat) |
||||
case key == f.FieldMap.resolve(FieldKeyLevel): |
||||
value = entry.Level.String() |
||||
case key == f.FieldMap.resolve(FieldKeyMsg): |
||||
value = entry.Message |
||||
case key == f.FieldMap.resolve(FieldKeyLogrusError): |
||||
value = entry.err |
||||
case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller(): |
||||
value = funcVal |
||||
case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller(): |
||||
value = fileVal |
||||
default: |
||||
value = data[key] |
||||
} |
||||
f.appendKeyValue(b, key, value) |
||||
} |
||||
} |
||||
|
||||
b.WriteByte('\n') |
||||
return b.Bytes(), nil |
||||
} |
||||
|
||||
func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) { |
||||
var levelColor int |
||||
switch entry.Level { |
||||
case DebugLevel, TraceLevel: |
||||
levelColor = gray |
||||
case WarnLevel: |
||||
levelColor = yellow |
||||
case ErrorLevel, FatalLevel, PanicLevel: |
||||
levelColor = red |
||||
case InfoLevel: |
||||
levelColor = blue |
||||
default: |
||||
levelColor = blue |
||||
} |
||||
|
||||
levelText := strings.ToUpper(entry.Level.String()) |
||||
if !f.DisableLevelTruncation && !f.PadLevelText { |
||||
levelText = levelText[0:4] |
||||
} |
||||
if f.PadLevelText { |
||||
// Generates the format string used in the next line, for example "%-6s" or "%-7s".
|
||||
// Based on the max level text length.
|
||||
formatString := "%-" + strconv.Itoa(f.levelTextMaxLength) + "s" |
||||
// Formats the level text by appending spaces up to the max length, for example:
|
||||
// - "INFO "
|
||||
// - "WARNING"
|
||||
levelText = fmt.Sprintf(formatString, levelText) |
||||
} |
||||
|
||||
// Remove a single newline if it already exists in the message to keep
|
||||
// the behavior of logrus text_formatter the same as the stdlib log package
|
||||
entry.Message = strings.TrimSuffix(entry.Message, "\n") |
||||
|
||||
caller := "" |
||||
if entry.HasCaller() { |
||||
funcVal := fmt.Sprintf("%s()", entry.Caller.Function) |
||||
fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line) |
||||
|
||||
if f.CallerPrettyfier != nil { |
||||
funcVal, fileVal = f.CallerPrettyfier(entry.Caller) |
||||
} |
||||
|
||||
if fileVal == "" { |
||||
caller = funcVal |
||||
} else if funcVal == "" { |
||||
caller = fileVal |
||||
} else { |
||||
caller = fileVal + " " + funcVal |
||||
} |
||||
} |
||||
|
||||
switch { |
||||
case f.DisableTimestamp: |
||||
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message) |
||||
case !f.FullTimestamp: |
||||
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message) |
||||
default: |
||||
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message) |
||||
} |
||||
for _, k := range keys { |
||||
v := data[k] |
||||
fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k) |
||||
f.appendValue(b, v) |
||||
} |
||||
} |
||||
|
||||
func (f *TextFormatter) needsQuoting(text string) bool { |
||||
if f.ForceQuote { |
||||
return true |
||||
} |
||||
if f.QuoteEmptyFields && len(text) == 0 { |
||||
return true |
||||
} |
||||
if f.DisableQuote { |
||||
return false |
||||
} |
||||
for _, ch := range text { |
||||
if !((ch >= 'a' && ch <= 'z') || |
||||
(ch >= 'A' && ch <= 'Z') || |
||||
(ch >= '0' && ch <= '9') || |
||||
ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) { |
||||
if b.Len() > 0 { |
||||
b.WriteByte(' ') |
||||
} |
||||
b.WriteString(key) |
||||
b.WriteByte('=') |
||||
f.appendValue(b, value) |
||||
} |
||||
|
||||
func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) { |
||||
stringVal, ok := value.(string) |
||||
if !ok { |
||||
stringVal = fmt.Sprint(value) |
||||
} |
||||
|
||||
if !f.needsQuoting(stringVal) { |
||||
b.WriteString(stringVal) |
||||
} else { |
||||
b.WriteString(fmt.Sprintf("%q", stringVal)) |
||||
} |
||||
} |
||||
@ -0,0 +1,70 @@ |
||||
package logrus |
||||
|
||||
import ( |
||||
"bufio" |
||||
"io" |
||||
"runtime" |
||||
) |
||||
|
||||
// Writer at INFO level. See WriterLevel for details.
|
||||
func (logger *Logger) Writer() *io.PipeWriter { |
||||
return logger.WriterLevel(InfoLevel) |
||||
} |
||||
|
||||
// WriterLevel returns an io.Writer that can be used to write arbitrary text to
|
||||
// the logger at the given log level. Each line written to the writer will be
|
||||
// printed in the usual way using formatters and hooks. The writer is part of an
|
||||
// io.Pipe and it is the callers responsibility to close the writer when done.
|
||||
// This can be used to override the standard library logger easily.
|
||||
func (logger *Logger) WriterLevel(level Level) *io.PipeWriter { |
||||
return NewEntry(logger).WriterLevel(level) |
||||
} |
||||
|
||||
func (entry *Entry) Writer() *io.PipeWriter { |
||||
return entry.WriterLevel(InfoLevel) |
||||
} |
||||
|
||||
func (entry *Entry) WriterLevel(level Level) *io.PipeWriter { |
||||
reader, writer := io.Pipe() |
||||
|
||||
var printFunc func(args ...interface{}) |
||||
|
||||
switch level { |
||||
case TraceLevel: |
||||
printFunc = entry.Trace |
||||
case DebugLevel: |
||||
printFunc = entry.Debug |
||||
case InfoLevel: |
||||
printFunc = entry.Info |
||||
case WarnLevel: |
||||
printFunc = entry.Warn |
||||
case ErrorLevel: |
||||
printFunc = entry.Error |
||||
case FatalLevel: |
||||
printFunc = entry.Fatal |
||||
case PanicLevel: |
||||
printFunc = entry.Panic |
||||
default: |
||||
printFunc = entry.Print |
||||
} |
||||
|
||||
go entry.writerScanner(reader, printFunc) |
||||
runtime.SetFinalizer(writer, writerFinalizer) |
||||
|
||||
return writer |
||||
} |
||||
|
||||
func (entry *Entry) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) { |
||||
scanner := bufio.NewScanner(reader) |
||||
for scanner.Scan() { |
||||
printFunc(scanner.Text()) |
||||
} |
||||
if err := scanner.Err(); err != nil { |
||||
entry.Errorf("Error while reading from Writer: %s", err) |
||||
} |
||||
reader.Close() |
||||
} |
||||
|
||||
func writerFinalizer(writer *io.PipeWriter) { |
||||
writer.Close() |
||||
} |
||||
@ -0,0 +1,27 @@ |
||||
Copyright (c) 2009 The Go Authors. All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Google Inc. nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -0,0 +1,22 @@ |
||||
Additional IP Rights Grant (Patents) |
||||
|
||||
"This implementation" means the copyrightable works distributed by |
||||
Google as part of the Go project. |
||||
|
||||
Google hereby grants to You a perpetual, worldwide, non-exclusive, |
||||
no-charge, royalty-free, irrevocable (except as stated in this section) |
||||
patent license to make, have made, use, offer to sell, sell, import, |
||||
transfer and otherwise run, modify and propagate the contents of this |
||||
implementation of Go, where such license applies only to those patent |
||||
claims, both currently owned or controlled by Google and acquired in |
||||
the future, licensable by Google that are necessarily infringed by this |
||||
implementation of Go. This grant does not include claims that would be |
||||
infringed only as a consequence of further modification of this |
||||
implementation. If you or your agent or exclusive licensee institute or |
||||
order or agree to the institution of patent litigation against any |
||||
entity (including a cross-claim or counterclaim in a lawsuit) alleging |
||||
that this implementation of Go or any code incorporated within this |
||||
implementation of Go constitutes direct or contributory patent |
||||
infringement, or inducement of patent infringement, then any patent |
||||
rights granted to you under this License for this implementation of Go |
||||
shall terminate as of the date such litigation is filed. |
||||
@ -0,0 +1,30 @@ |
||||
// Copyright 2020 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package unsafeheader contains header declarations for the Go runtime's
|
||||
// slice and string implementations.
|
||||
//
|
||||
// This package allows x/sys to use types equivalent to
|
||||
// reflect.SliceHeader and reflect.StringHeader without introducing
|
||||
// a dependency on the (relatively heavy) "reflect" package.
|
||||
package unsafeheader |
||||
|
||||
import ( |
||||
"unsafe" |
||||
) |
||||
|
||||
// Slice is the runtime representation of a slice.
|
||||
// It cannot be used safely or portably and its representation may change in a later release.
|
||||
type Slice struct { |
||||
Data unsafe.Pointer |
||||
Len int |
||||
Cap int |
||||
} |
||||
|
||||
// String is the runtime representation of a string.
|
||||
// It cannot be used safely or portably and its representation may change in a later release.
|
||||
type String struct { |
||||
Data unsafe.Pointer |
||||
Len int |
||||
} |
||||
@ -0,0 +1,2 @@ |
||||
_obj/ |
||||
unix.test |
||||
@ -0,0 +1,184 @@ |
||||
# Building `sys/unix` |
||||
|
||||
The sys/unix package provides access to the raw system call interface of the |
||||
underlying operating system. See: https://godoc.org/golang.org/x/sys/unix |
||||
|
||||
Porting Go to a new architecture/OS combination or adding syscalls, types, or |
||||
constants to an existing architecture/OS pair requires some manual effort; |
||||
however, there are tools that automate much of the process. |
||||
|
||||
## Build Systems |
||||
|
||||
There are currently two ways we generate the necessary files. We are currently |
||||
migrating the build system to use containers so the builds are reproducible. |
||||
This is being done on an OS-by-OS basis. Please update this documentation as |
||||
components of the build system change. |
||||
|
||||
### Old Build System (currently for `GOOS != "linux"`) |
||||
|
||||
The old build system generates the Go files based on the C header files |
||||
present on your system. This means that files |
||||
for a given GOOS/GOARCH pair must be generated on a system with that OS and |
||||
architecture. This also means that the generated code can differ from system |
||||
to system, based on differences in the header files. |
||||
|
||||
To avoid this, if you are using the old build system, only generate the Go |
||||
files on an installation with unmodified header files. It is also important to |
||||
keep track of which version of the OS the files were generated from (ex. |
||||
Darwin 14 vs Darwin 15). This makes it easier to track the progress of changes |
||||
and have each OS upgrade correspond to a single change. |
||||
|
||||
To build the files for your current OS and architecture, make sure GOOS and |
||||
GOARCH are set correctly and run `mkall.sh`. This will generate the files for |
||||
your specific system. Running `mkall.sh -n` shows the commands that will be run. |
||||
|
||||
Requirements: bash, go |
||||
|
||||
### New Build System (currently for `GOOS == "linux"`) |
||||
|
||||
The new build system uses a Docker container to generate the go files directly |
||||
from source checkouts of the kernel and various system libraries. This means |
||||
that on any platform that supports Docker, all the files using the new build |
||||
system can be generated at once, and generated files will not change based on |
||||
what the person running the scripts has installed on their computer. |
||||
|
||||
The OS specific files for the new build system are located in the `${GOOS}` |
||||
directory, and the build is coordinated by the `${GOOS}/mkall.go` program. When |
||||
the kernel or system library updates, modify the Dockerfile at |
||||
`${GOOS}/Dockerfile` to checkout the new release of the source. |
||||
|
||||
To build all the files under the new build system, you must be on an amd64/Linux |
||||
system and have your GOOS and GOARCH set accordingly. Running `mkall.sh` will |
||||
then generate all of the files for all of the GOOS/GOARCH pairs in the new build |
||||
system. Running `mkall.sh -n` shows the commands that will be run. |
||||
|
||||
Requirements: bash, go, docker |
||||
|
||||
## Component files |
||||
|
||||
This section describes the various files used in the code generation process. |
||||
It also contains instructions on how to modify these files to add a new |
||||
architecture/OS or to add additional syscalls, types, or constants. Note that |
||||
if you are using the new build system, the scripts/programs cannot be called normally. |
||||
They must be called from within the docker container. |
||||
|
||||
### asm files |
||||
|
||||
The hand-written assembly file at `asm_${GOOS}_${GOARCH}.s` implements system |
||||
call dispatch. There are three entry points: |
||||
``` |
||||
func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr) |
||||
func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) |
||||
func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr) |
||||
``` |
||||
The first and second are the standard ones; they differ only in how many |
||||
arguments can be passed to the kernel. The third is for low-level use by the |
||||
ForkExec wrapper. Unlike the first two, it does not call into the scheduler to |
||||
let it know that a system call is running. |
||||
|
||||
When porting Go to a new architecture/OS, this file must be implemented for |
||||
each GOOS/GOARCH pair. |
||||
|
||||
### mksysnum |
||||
|
||||
Mksysnum is a Go program located at `${GOOS}/mksysnum.go` (or `mksysnum_${GOOS}.go` |
||||
for the old system). This program takes in a list of header files containing the |
||||
syscall number declarations and parses them to produce the corresponding list of |
||||
Go numeric constants. See `zsysnum_${GOOS}_${GOARCH}.go` for the generated |
||||
constants. |
||||
|
||||
Adding new syscall numbers is mostly done by running the build on a sufficiently |
||||
new installation of the target OS (or updating the source checkouts for the |
||||
new build system). However, depending on the OS, you may need to update the |
||||
parsing in mksysnum. |
||||
|
||||
### mksyscall.go |
||||
|
||||
The `syscall.go`, `syscall_${GOOS}.go`, `syscall_${GOOS}_${GOARCH}.go` are |
||||
hand-written Go files which implement system calls (for unix, the specific OS, |
||||
or the specific OS/Architecture pair respectively) that need special handling |
||||
and list `//sys` comments giving prototypes for ones that can be generated. |
||||
|
||||
The mksyscall.go program takes the `//sys` and `//sysnb` comments and converts |
||||
them into syscalls. This requires the name of the prototype in the comment to |
||||
match a syscall number in the `zsysnum_${GOOS}_${GOARCH}.go` file. The function |
||||
prototype can be exported (capitalized) or not. |
||||
|
||||
Adding a new syscall often just requires adding a new `//sys` function prototype |
||||
with the desired arguments and a capitalized name so it is exported. However, if |
||||
you want the interface to the syscall to be different, often one will make an |
||||
unexported `//sys` prototype, and then write a custom wrapper in |
||||
`syscall_${GOOS}.go`. |
||||
|
||||
### types files |
||||
|
||||
For each OS, there is a hand-written Go file at `${GOOS}/types.go` (or |
||||
`types_${GOOS}.go` on the old system). This file includes standard C headers and |
||||
creates Go type aliases to the corresponding C types. The file is then fed |
||||
through godef to get the Go compatible definitions. Finally, the generated code |
||||
is fed though mkpost.go to format the code correctly and remove any hidden or |
||||
private identifiers. This cleaned-up code is written to |
||||
`ztypes_${GOOS}_${GOARCH}.go`. |
||||
|
||||
The hardest part about preparing this file is figuring out which headers to |
||||
include and which symbols need to be `#define`d to get the actual data |
||||
structures that pass through to the kernel system calls. Some C libraries |
||||
preset alternate versions for binary compatibility and translate them on the |
||||
way in and out of system calls, but there is almost always a `#define` that can |
||||
get the real ones. |
||||
See `types_darwin.go` and `linux/types.go` for examples. |
||||
|
||||
To add a new type, add in the necessary include statement at the top of the |
||||
file (if it is not already there) and add in a type alias line. Note that if |
||||
your type is significantly different on different architectures, you may need |
||||
some `#if/#elif` macros in your include statements. |
||||
|
||||
### mkerrors.sh |
||||
|
||||
This script is used to generate the system's various constants. This doesn't |
||||
just include the error numbers and error strings, but also the signal numbers |
||||
and a wide variety of miscellaneous constants. The constants come from the list |
||||
of include files in the `includes_${uname}` variable. A regex then picks out |
||||
the desired `#define` statements, and generates the corresponding Go constants. |
||||
The error numbers and strings are generated from `#include <errno.h>`, and the |
||||
signal numbers and strings are generated from `#include <signal.h>`. All of |
||||
these constants are written to `zerrors_${GOOS}_${GOARCH}.go` via a C program, |
||||
`_errors.c`, which prints out all the constants. |
||||
|
||||
To add a constant, add the header that includes it to the appropriate variable. |
||||
Then, edit the regex (if necessary) to match the desired constant. Avoid making |
||||
the regex too broad to avoid matching unintended constants. |
||||
|
||||
### internal/mkmerge |
||||
|
||||
This program is used to extract duplicate const, func, and type declarations |
||||
from the generated architecture-specific files listed below, and merge these |
||||
into a common file for each OS. |
||||
|
||||
The merge is performed in the following steps: |
||||
1. Construct the set of common code that is idential in all architecture-specific files. |
||||
2. Write this common code to the merged file. |
||||
3. Remove the common code from all architecture-specific files. |
||||
|
||||
|
||||
## Generated files |
||||
|
||||
### `zerrors_${GOOS}_${GOARCH}.go` |
||||
|
||||
A file containing all of the system's generated error numbers, error strings, |
||||
signal numbers, and constants. Generated by `mkerrors.sh` (see above). |
||||
|
||||
### `zsyscall_${GOOS}_${GOARCH}.go` |
||||
|
||||
A file containing all the generated syscalls for a specific GOOS and GOARCH. |
||||
Generated by `mksyscall.go` (see above). |
||||
|
||||
### `zsysnum_${GOOS}_${GOARCH}.go` |
||||
|
||||
A list of numeric constants for all the syscall number of the specific GOOS |
||||
and GOARCH. Generated by mksysnum (see above). |
||||
|
||||
### `ztypes_${GOOS}_${GOARCH}.go` |
||||
|
||||
A file containing Go types for passing into (or returning from) syscalls. |
||||
Generated by godefs and the types file (see above). |
||||
@ -0,0 +1,86 @@ |
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// CPU affinity functions
|
||||
|
||||
package unix |
||||
|
||||
import ( |
||||
"math/bits" |
||||
"unsafe" |
||||
) |
||||
|
||||
const cpuSetSize = _CPU_SETSIZE / _NCPUBITS |
||||
|
||||
// CPUSet represents a CPU affinity mask.
|
||||
type CPUSet [cpuSetSize]cpuMask |
||||
|
||||
func schedAffinity(trap uintptr, pid int, set *CPUSet) error { |
||||
_, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set))) |
||||
if e != 0 { |
||||
return errnoErr(e) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// SchedGetaffinity gets the CPU affinity mask of the thread specified by pid.
|
||||
// If pid is 0 the calling thread is used.
|
||||
func SchedGetaffinity(pid int, set *CPUSet) error { |
||||
return schedAffinity(SYS_SCHED_GETAFFINITY, pid, set) |
||||
} |
||||
|
||||
// SchedSetaffinity sets the CPU affinity mask of the thread specified by pid.
|
||||
// If pid is 0 the calling thread is used.
|
||||
func SchedSetaffinity(pid int, set *CPUSet) error { |
||||
return schedAffinity(SYS_SCHED_SETAFFINITY, pid, set) |
||||
} |
||||
|
||||
// Zero clears the set s, so that it contains no CPUs.
|
||||
func (s *CPUSet) Zero() { |
||||
for i := range s { |
||||
s[i] = 0 |
||||
} |
||||
} |
||||
|
||||
func cpuBitsIndex(cpu int) int { |
||||
return cpu / _NCPUBITS |
||||
} |
||||
|
||||
func cpuBitsMask(cpu int) cpuMask { |
||||
return cpuMask(1 << (uint(cpu) % _NCPUBITS)) |
||||
} |
||||
|
||||
// Set adds cpu to the set s.
|
||||
func (s *CPUSet) Set(cpu int) { |
||||
i := cpuBitsIndex(cpu) |
||||
if i < len(s) { |
||||
s[i] |= cpuBitsMask(cpu) |
||||
} |
||||
} |
||||
|
||||
// Clear removes cpu from the set s.
|
||||
func (s *CPUSet) Clear(cpu int) { |
||||
i := cpuBitsIndex(cpu) |
||||
if i < len(s) { |
||||
s[i] &^= cpuBitsMask(cpu) |
||||
} |
||||
} |
||||
|
||||
// IsSet reports whether cpu is in the set s.
|
||||
func (s *CPUSet) IsSet(cpu int) bool { |
||||
i := cpuBitsIndex(cpu) |
||||
if i < len(s) { |
||||
return s[i]&cpuBitsMask(cpu) != 0 |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// Count returns the number of CPUs in the set s.
|
||||
func (s *CPUSet) Count() int { |
||||
c := 0 |
||||
for _, b := range s { |
||||
c += bits.OnesCount64(uint64(b)) |
||||
} |
||||
return c |
||||
} |
||||
@ -0,0 +1,15 @@ |
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) && go1.9
|
||||
// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
|
||||
// +build go1.9
|
||||
|
||||
package unix |
||||
|
||||
import "syscall" |
||||
|
||||
type Signal = syscall.Signal |
||||
type Errno = syscall.Errno |
||||
type SysProcAttr = syscall.SysProcAttr |
||||
@ -0,0 +1,18 @@ |
||||
// Copyright 2018 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build gc |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for ppc64, AIX are implemented in runtime/syscall_aix.go |
||||
// |
||||
|
||||
TEXT ·syscall6(SB),NOSPLIT,$0-88 |
||||
JMP syscall·syscall6(SB) |
||||
|
||||
TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 |
||||
JMP syscall·rawSyscall6(SB) |
||||
@ -0,0 +1,29 @@ |
||||
// Copyright 2021 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build (freebsd || netbsd || openbsd) && gc |
||||
// +build freebsd netbsd openbsd |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// System call support for 386 BSD |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-28 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-40 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-52 |
||||
JMP syscall·Syscall9(SB) |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 |
||||
JMP syscall·RawSyscall6(SB) |
||||
@ -0,0 +1,29 @@ |
||||
// Copyright 2021 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc |
||||
// +build darwin dragonfly freebsd netbsd openbsd |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// System call support for AMD64 BSD |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-104 |
||||
JMP syscall·Syscall9(SB) |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
@ -0,0 +1,29 @@ |
||||
// Copyright 2021 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build (freebsd || netbsd || openbsd) && gc |
||||
// +build freebsd netbsd openbsd |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// System call support for ARM BSD |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-28 |
||||
B syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-40 |
||||
B syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-52 |
||||
B syscall·Syscall9(SB) |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 |
||||
B syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 |
||||
B syscall·RawSyscall6(SB) |
||||
@ -0,0 +1,29 @@ |
||||
// Copyright 2021 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build (darwin || freebsd || netbsd || openbsd) && gc |
||||
// +build darwin freebsd netbsd openbsd |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// System call support for ARM64 BSD |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-104 |
||||
JMP syscall·Syscall9(SB) |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
@ -0,0 +1,31 @@ |
||||
// Copyright 2022 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build (darwin || freebsd || netbsd || openbsd) && gc |
||||
// +build darwin freebsd netbsd openbsd |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System call support for ppc64, BSD |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-104 |
||||
JMP syscall·Syscall9(SB) |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
@ -0,0 +1,29 @@ |
||||
// Copyright 2021 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build (darwin || freebsd || netbsd || openbsd) && gc |
||||
// +build darwin freebsd netbsd openbsd |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// System call support for RISCV64 BSD |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-104 |
||||
JMP syscall·Syscall9(SB) |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
@ -0,0 +1,66 @@ |
||||
// Copyright 2009 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build gc |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for 386, Linux |
||||
// |
||||
|
||||
// See ../runtime/sys_linux_386.s for the reason why we always use int 0x80 |
||||
// instead of the glibc-specific "CALL 0x10(GS)". |
||||
#define INVOKE_SYSCALL INT $0x80 |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-28 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-40 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-24 |
||||
CALL runtime·entersyscall(SB) |
||||
MOVL trap+0(FP), AX // syscall entry |
||||
MOVL a1+4(FP), BX |
||||
MOVL a2+8(FP), CX |
||||
MOVL a3+12(FP), DX |
||||
MOVL $0, SI |
||||
MOVL $0, DI |
||||
INVOKE_SYSCALL |
||||
MOVL AX, r1+16(FP) |
||||
MOVL DX, r2+20(FP) |
||||
CALL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 |
||||
JMP syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24 |
||||
MOVL trap+0(FP), AX // syscall entry |
||||
MOVL a1+4(FP), BX |
||||
MOVL a2+8(FP), CX |
||||
MOVL a3+12(FP), DX |
||||
MOVL $0, SI |
||||
MOVL $0, DI |
||||
INVOKE_SYSCALL |
||||
MOVL AX, r1+16(FP) |
||||
MOVL DX, r2+20(FP) |
||||
RET |
||||
|
||||
TEXT ·socketcall(SB),NOSPLIT,$0-36 |
||||
JMP syscall·socketcall(SB) |
||||
|
||||
TEXT ·rawsocketcall(SB),NOSPLIT,$0-36 |
||||
JMP syscall·rawsocketcall(SB) |
||||
|
||||
TEXT ·seek(SB),NOSPLIT,$0-28 |
||||
JMP syscall·seek(SB) |
||||
@ -0,0 +1,58 @@ |
||||
// Copyright 2009 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build gc |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for AMD64, Linux |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 |
||||
CALL runtime·entersyscall(SB) |
||||
MOVQ a1+8(FP), DI |
||||
MOVQ a2+16(FP), SI |
||||
MOVQ a3+24(FP), DX |
||||
MOVQ $0, R10 |
||||
MOVQ $0, R8 |
||||
MOVQ $0, R9 |
||||
MOVQ trap+0(FP), AX // syscall entry |
||||
SYSCALL |
||||
MOVQ AX, r1+32(FP) |
||||
MOVQ DX, r2+40(FP) |
||||
CALL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 |
||||
MOVQ a1+8(FP), DI |
||||
MOVQ a2+16(FP), SI |
||||
MOVQ a3+24(FP), DX |
||||
MOVQ $0, R10 |
||||
MOVQ $0, R8 |
||||
MOVQ $0, R9 |
||||
MOVQ trap+0(FP), AX // syscall entry |
||||
SYSCALL |
||||
MOVQ AX, r1+32(FP) |
||||
MOVQ DX, r2+40(FP) |
||||
RET |
||||
|
||||
TEXT ·gettimeofday(SB),NOSPLIT,$0-16 |
||||
JMP syscall·gettimeofday(SB) |
||||
@ -0,0 +1,57 @@ |
||||
// Copyright 2009 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build gc |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for arm, Linux |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-28 |
||||
B syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-40 |
||||
B syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-24 |
||||
BL runtime·entersyscall(SB) |
||||
MOVW trap+0(FP), R7 |
||||
MOVW a1+4(FP), R0 |
||||
MOVW a2+8(FP), R1 |
||||
MOVW a3+12(FP), R2 |
||||
MOVW $0, R3 |
||||
MOVW $0, R4 |
||||
MOVW $0, R5 |
||||
SWI $0 |
||||
MOVW R0, r1+16(FP) |
||||
MOVW $0, R0 |
||||
MOVW R0, r2+20(FP) |
||||
BL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 |
||||
B syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 |
||||
B syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24 |
||||
MOVW trap+0(FP), R7 // syscall entry |
||||
MOVW a1+4(FP), R0 |
||||
MOVW a2+8(FP), R1 |
||||
MOVW a3+12(FP), R2 |
||||
SWI $0 |
||||
MOVW R0, r1+16(FP) |
||||
MOVW $0, R0 |
||||
MOVW R0, r2+20(FP) |
||||
RET |
||||
|
||||
TEXT ·seek(SB),NOSPLIT,$0-28 |
||||
B syscall·seek(SB) |
||||
@ -0,0 +1,53 @@ |
||||
// Copyright 2015 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build linux && arm64 && gc |
||||
// +build linux |
||||
// +build arm64 |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
B syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
B syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 |
||||
BL runtime·entersyscall(SB) |
||||
MOVD a1+8(FP), R0 |
||||
MOVD a2+16(FP), R1 |
||||
MOVD a3+24(FP), R2 |
||||
MOVD $0, R3 |
||||
MOVD $0, R4 |
||||
MOVD $0, R5 |
||||
MOVD trap+0(FP), R8 // syscall entry |
||||
SVC |
||||
MOVD R0, r1+32(FP) // r1 |
||||
MOVD R1, r2+40(FP) // r2 |
||||
BL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
B syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
B syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 |
||||
MOVD a1+8(FP), R0 |
||||
MOVD a2+16(FP), R1 |
||||
MOVD a3+24(FP), R2 |
||||
MOVD $0, R3 |
||||
MOVD $0, R4 |
||||
MOVD $0, R5 |
||||
MOVD trap+0(FP), R8 // syscall entry |
||||
SVC |
||||
MOVD R0, r1+32(FP) |
||||
MOVD R1, r2+40(FP) |
||||
RET |
||||
@ -0,0 +1,54 @@ |
||||
// Copyright 2022 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build linux && loong64 && gc |
||||
// +build linux |
||||
// +build loong64 |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 |
||||
JAL runtime·entersyscall(SB) |
||||
MOVV a1+8(FP), R4 |
||||
MOVV a2+16(FP), R5 |
||||
MOVV a3+24(FP), R6 |
||||
MOVV R0, R7 |
||||
MOVV R0, R8 |
||||
MOVV R0, R9 |
||||
MOVV trap+0(FP), R11 // syscall entry |
||||
SYSCALL |
||||
MOVV R4, r1+32(FP) |
||||
MOVV R0, r2+40(FP) // r2 is not used. Always set to 0 |
||||
JAL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 |
||||
MOVV a1+8(FP), R4 |
||||
MOVV a2+16(FP), R5 |
||||
MOVV a3+24(FP), R6 |
||||
MOVV R0, R7 |
||||
MOVV R0, R8 |
||||
MOVV R0, R9 |
||||
MOVV trap+0(FP), R11 // syscall entry |
||||
SYSCALL |
||||
MOVV R4, r1+32(FP) |
||||
MOVV R0, r2+40(FP) // r2 is not used. Always set to 0 |
||||
RET |
||||
@ -0,0 +1,57 @@ |
||||
// Copyright 2015 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build linux && (mips64 || mips64le) && gc |
||||
// +build linux |
||||
// +build mips64 mips64le |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for mips64, Linux |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 |
||||
JAL runtime·entersyscall(SB) |
||||
MOVV a1+8(FP), R4 |
||||
MOVV a2+16(FP), R5 |
||||
MOVV a3+24(FP), R6 |
||||
MOVV R0, R7 |
||||
MOVV R0, R8 |
||||
MOVV R0, R9 |
||||
MOVV trap+0(FP), R2 // syscall entry |
||||
SYSCALL |
||||
MOVV R2, r1+32(FP) |
||||
MOVV R3, r2+40(FP) |
||||
JAL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 |
||||
MOVV a1+8(FP), R4 |
||||
MOVV a2+16(FP), R5 |
||||
MOVV a3+24(FP), R6 |
||||
MOVV R0, R7 |
||||
MOVV R0, R8 |
||||
MOVV R0, R9 |
||||
MOVV trap+0(FP), R2 // syscall entry |
||||
SYSCALL |
||||
MOVV R2, r1+32(FP) |
||||
MOVV R3, r2+40(FP) |
||||
RET |
||||
@ -0,0 +1,55 @@ |
||||
// Copyright 2016 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build linux && (mips || mipsle) && gc |
||||
// +build linux |
||||
// +build mips mipsle |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for mips, Linux |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-28 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-40 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-52 |
||||
JMP syscall·Syscall9(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-24 |
||||
JAL runtime·entersyscall(SB) |
||||
MOVW a1+4(FP), R4 |
||||
MOVW a2+8(FP), R5 |
||||
MOVW a3+12(FP), R6 |
||||
MOVW R0, R7 |
||||
MOVW trap+0(FP), R2 // syscall entry |
||||
SYSCALL |
||||
MOVW R2, r1+16(FP) // r1 |
||||
MOVW R3, r2+20(FP) // r2 |
||||
JAL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 |
||||
JMP syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24 |
||||
MOVW a1+4(FP), R4 |
||||
MOVW a2+8(FP), R5 |
||||
MOVW a3+12(FP), R6 |
||||
MOVW trap+0(FP), R2 // syscall entry |
||||
SYSCALL |
||||
MOVW R2, r1+16(FP) |
||||
MOVW R3, r2+20(FP) |
||||
RET |
||||
@ -0,0 +1,45 @@ |
||||
// Copyright 2014 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build linux && (ppc64 || ppc64le) && gc |
||||
// +build linux |
||||
// +build ppc64 ppc64le |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for ppc64, Linux |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 |
||||
BL runtime·entersyscall(SB) |
||||
MOVD a1+8(FP), R3 |
||||
MOVD a2+16(FP), R4 |
||||
MOVD a3+24(FP), R5 |
||||
MOVD R0, R6 |
||||
MOVD R0, R7 |
||||
MOVD R0, R8 |
||||
MOVD trap+0(FP), R9 // syscall entry |
||||
SYSCALL R9 |
||||
MOVD R3, r1+32(FP) |
||||
MOVD R4, r2+40(FP) |
||||
BL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 |
||||
MOVD a1+8(FP), R3 |
||||
MOVD a2+16(FP), R4 |
||||
MOVD a3+24(FP), R5 |
||||
MOVD R0, R6 |
||||
MOVD R0, R7 |
||||
MOVD R0, R8 |
||||
MOVD trap+0(FP), R9 // syscall entry |
||||
SYSCALL R9 |
||||
MOVD R3, r1+32(FP) |
||||
MOVD R4, r2+40(FP) |
||||
RET |
||||
@ -0,0 +1,49 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build riscv64 && gc |
||||
// +build riscv64 |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for linux/riscv64. |
||||
// |
||||
// Where available, just jump to package syscall's implementation of |
||||
// these functions. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 |
||||
CALL runtime·entersyscall(SB) |
||||
MOV a1+8(FP), A0 |
||||
MOV a2+16(FP), A1 |
||||
MOV a3+24(FP), A2 |
||||
MOV trap+0(FP), A7 // syscall entry |
||||
ECALL |
||||
MOV A0, r1+32(FP) // r1 |
||||
MOV A1, r2+40(FP) // r2 |
||||
CALL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 |
||||
MOV a1+8(FP), A0 |
||||
MOV a2+16(FP), A1 |
||||
MOV a3+24(FP), A2 |
||||
MOV trap+0(FP), A7 // syscall entry |
||||
ECALL |
||||
MOV A0, r1+32(FP) |
||||
MOV A1, r2+40(FP) |
||||
RET |
||||
@ -0,0 +1,57 @@ |
||||
// Copyright 2016 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build linux && s390x && gc |
||||
// +build linux |
||||
// +build s390x |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for s390x, Linux |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
BR syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
BR syscall·Syscall6(SB) |
||||
|
||||
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 |
||||
BL runtime·entersyscall(SB) |
||||
MOVD a1+8(FP), R2 |
||||
MOVD a2+16(FP), R3 |
||||
MOVD a3+24(FP), R4 |
||||
MOVD $0, R5 |
||||
MOVD $0, R6 |
||||
MOVD $0, R7 |
||||
MOVD trap+0(FP), R1 // syscall entry |
||||
SYSCALL |
||||
MOVD R2, r1+32(FP) |
||||
MOVD R3, r2+40(FP) |
||||
BL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
BR syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
BR syscall·RawSyscall6(SB) |
||||
|
||||
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 |
||||
MOVD a1+8(FP), R2 |
||||
MOVD a2+16(FP), R3 |
||||
MOVD a3+24(FP), R4 |
||||
MOVD $0, R5 |
||||
MOVD $0, R6 |
||||
MOVD $0, R7 |
||||
MOVD trap+0(FP), R1 // syscall entry |
||||
SYSCALL |
||||
MOVD R2, r1+32(FP) |
||||
MOVD R3, r2+40(FP) |
||||
RET |
||||
@ -0,0 +1,30 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build gc |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System call support for mips64, OpenBSD |
||||
// |
||||
|
||||
// Just jump to package syscall's implementation for all these functions. |
||||
// The runtime may know about them. |
||||
|
||||
TEXT ·Syscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·Syscall(SB) |
||||
|
||||
TEXT ·Syscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·Syscall6(SB) |
||||
|
||||
TEXT ·Syscall9(SB),NOSPLIT,$0-104 |
||||
JMP syscall·Syscall9(SB) |
||||
|
||||
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 |
||||
JMP syscall·RawSyscall(SB) |
||||
|
||||
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 |
||||
JMP syscall·RawSyscall6(SB) |
||||
@ -0,0 +1,18 @@ |
||||
// Copyright 2014 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build gc |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
// |
||||
// System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go |
||||
// |
||||
|
||||
TEXT ·sysvicall6(SB),NOSPLIT,$0-88 |
||||
JMP syscall·sysvicall6(SB) |
||||
|
||||
TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 |
||||
JMP syscall·rawSysvicall6(SB) |
||||
@ -0,0 +1,426 @@ |
||||
// Copyright 2020 The Go Authors. All rights reserved. |
||||
// Use of this source code is governed by a BSD-style |
||||
// license that can be found in the LICENSE file. |
||||
|
||||
//go:build zos && s390x && gc |
||||
// +build zos |
||||
// +build s390x |
||||
// +build gc |
||||
|
||||
#include "textflag.h" |
||||
|
||||
#define PSALAA 1208(R0) |
||||
#define GTAB64(x) 80(x) |
||||
#define LCA64(x) 88(x) |
||||
#define CAA(x) 8(x) |
||||
#define EDCHPXV(x) 1016(x) // in the CAA |
||||
#define SAVSTACK_ASYNC(x) 336(x) // in the LCA |
||||
|
||||
// SS_*, where x=SAVSTACK_ASYNC |
||||
#define SS_LE(x) 0(x) |
||||
#define SS_GO(x) 8(x) |
||||
#define SS_ERRNO(x) 16(x) |
||||
#define SS_ERRNOJR(x) 20(x) |
||||
|
||||
#define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6
|
||||
|
||||
TEXT ·clearErrno(SB),NOSPLIT,$0-0 |
||||
BL addrerrno<>(SB) |
||||
MOVD $0, 0(R3) |
||||
RET |
||||
|
||||
// Returns the address of errno in R3. |
||||
TEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0 |
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get __errno FuncDesc. |
||||
MOVD CAA(R8), R9 |
||||
MOVD EDCHPXV(R9), R9 |
||||
ADD $(0x156*16), R9 |
||||
LMG 0(R9), R5, R6 |
||||
|
||||
// Switch to saved LE stack. |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R4 |
||||
MOVD $0, 0(R9) |
||||
|
||||
// Call __errno function. |
||||
LE_CALL |
||||
NOPH |
||||
|
||||
// Switch back to Go stack. |
||||
XOR R0, R0 // Restore R0 to $0. |
||||
MOVD R4, 0(R9) // Save stack pointer. |
||||
RET |
||||
|
||||
TEXT ·syscall_syscall(SB),NOSPLIT,$0-56 |
||||
BL runtime·entersyscall(SB) |
||||
MOVD a1+8(FP), R1 |
||||
MOVD a2+16(FP), R2 |
||||
MOVD a3+24(FP), R3 |
||||
|
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get function. |
||||
MOVD CAA(R8), R9 |
||||
MOVD EDCHPXV(R9), R9 |
||||
MOVD trap+0(FP), R5 |
||||
SLD $4, R5 |
||||
ADD R5, R9 |
||||
LMG 0(R9), R5, R6 |
||||
|
||||
// Restore LE stack. |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R4 |
||||
MOVD $0, 0(R9) |
||||
|
||||
// Call function. |
||||
LE_CALL |
||||
NOPH |
||||
XOR R0, R0 // Restore R0 to $0. |
||||
MOVD R4, 0(R9) // Save stack pointer. |
||||
|
||||
MOVD R3, r1+32(FP) |
||||
MOVD R0, r2+40(FP) |
||||
MOVD R0, err+48(FP) |
||||
MOVW R3, R4 |
||||
CMP R4, $-1 |
||||
BNE done |
||||
BL addrerrno<>(SB) |
||||
MOVWZ 0(R3), R3 |
||||
MOVD R3, err+48(FP) |
||||
done: |
||||
BL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56 |
||||
MOVD a1+8(FP), R1 |
||||
MOVD a2+16(FP), R2 |
||||
MOVD a3+24(FP), R3 |
||||
|
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get function. |
||||
MOVD CAA(R8), R9 |
||||
MOVD EDCHPXV(R9), R9 |
||||
MOVD trap+0(FP), R5 |
||||
SLD $4, R5 |
||||
ADD R5, R9 |
||||
LMG 0(R9), R5, R6 |
||||
|
||||
// Restore LE stack. |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R4 |
||||
MOVD $0, 0(R9) |
||||
|
||||
// Call function. |
||||
LE_CALL |
||||
NOPH |
||||
XOR R0, R0 // Restore R0 to $0. |
||||
MOVD R4, 0(R9) // Save stack pointer. |
||||
|
||||
MOVD R3, r1+32(FP) |
||||
MOVD R0, r2+40(FP) |
||||
MOVD R0, err+48(FP) |
||||
MOVW R3, R4 |
||||
CMP R4, $-1 |
||||
BNE done |
||||
BL addrerrno<>(SB) |
||||
MOVWZ 0(R3), R3 |
||||
MOVD R3, err+48(FP) |
||||
done: |
||||
RET |
||||
|
||||
TEXT ·syscall_syscall6(SB),NOSPLIT,$0-80 |
||||
BL runtime·entersyscall(SB) |
||||
MOVD a1+8(FP), R1 |
||||
MOVD a2+16(FP), R2 |
||||
MOVD a3+24(FP), R3 |
||||
|
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get function. |
||||
MOVD CAA(R8), R9 |
||||
MOVD EDCHPXV(R9), R9 |
||||
MOVD trap+0(FP), R5 |
||||
SLD $4, R5 |
||||
ADD R5, R9 |
||||
LMG 0(R9), R5, R6 |
||||
|
||||
// Restore LE stack. |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R4 |
||||
MOVD $0, 0(R9) |
||||
|
||||
// Fill in parameter list. |
||||
MOVD a4+32(FP), R12 |
||||
MOVD R12, (2176+24)(R4) |
||||
MOVD a5+40(FP), R12 |
||||
MOVD R12, (2176+32)(R4) |
||||
MOVD a6+48(FP), R12 |
||||
MOVD R12, (2176+40)(R4) |
||||
|
||||
// Call function. |
||||
LE_CALL |
||||
NOPH |
||||
XOR R0, R0 // Restore R0 to $0. |
||||
MOVD R4, 0(R9) // Save stack pointer. |
||||
|
||||
MOVD R3, r1+56(FP) |
||||
MOVD R0, r2+64(FP) |
||||
MOVD R0, err+72(FP) |
||||
MOVW R3, R4 |
||||
CMP R4, $-1 |
||||
BNE done |
||||
BL addrerrno<>(SB) |
||||
MOVWZ 0(R3), R3 |
||||
MOVD R3, err+72(FP) |
||||
done: |
||||
BL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80 |
||||
MOVD a1+8(FP), R1 |
||||
MOVD a2+16(FP), R2 |
||||
MOVD a3+24(FP), R3 |
||||
|
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get function. |
||||
MOVD CAA(R8), R9 |
||||
MOVD EDCHPXV(R9), R9 |
||||
MOVD trap+0(FP), R5 |
||||
SLD $4, R5 |
||||
ADD R5, R9 |
||||
LMG 0(R9), R5, R6 |
||||
|
||||
// Restore LE stack. |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R4 |
||||
MOVD $0, 0(R9) |
||||
|
||||
// Fill in parameter list. |
||||
MOVD a4+32(FP), R12 |
||||
MOVD R12, (2176+24)(R4) |
||||
MOVD a5+40(FP), R12 |
||||
MOVD R12, (2176+32)(R4) |
||||
MOVD a6+48(FP), R12 |
||||
MOVD R12, (2176+40)(R4) |
||||
|
||||
// Call function. |
||||
LE_CALL |
||||
NOPH |
||||
XOR R0, R0 // Restore R0 to $0. |
||||
MOVD R4, 0(R9) // Save stack pointer. |
||||
|
||||
MOVD R3, r1+56(FP) |
||||
MOVD R0, r2+64(FP) |
||||
MOVD R0, err+72(FP) |
||||
MOVW R3, R4 |
||||
CMP R4, $-1 |
||||
BNE done |
||||
BL ·rrno<>(SB) |
||||
MOVWZ 0(R3), R3 |
||||
MOVD R3, err+72(FP) |
||||
done: |
||||
RET |
||||
|
||||
TEXT ·syscall_syscall9(SB),NOSPLIT,$0 |
||||
BL runtime·entersyscall(SB) |
||||
MOVD a1+8(FP), R1 |
||||
MOVD a2+16(FP), R2 |
||||
MOVD a3+24(FP), R3 |
||||
|
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get function. |
||||
MOVD CAA(R8), R9 |
||||
MOVD EDCHPXV(R9), R9 |
||||
MOVD trap+0(FP), R5 |
||||
SLD $4, R5 |
||||
ADD R5, R9 |
||||
LMG 0(R9), R5, R6 |
||||
|
||||
// Restore LE stack. |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R4 |
||||
MOVD $0, 0(R9) |
||||
|
||||
// Fill in parameter list. |
||||
MOVD a4+32(FP), R12 |
||||
MOVD R12, (2176+24)(R4) |
||||
MOVD a5+40(FP), R12 |
||||
MOVD R12, (2176+32)(R4) |
||||
MOVD a6+48(FP), R12 |
||||
MOVD R12, (2176+40)(R4) |
||||
MOVD a7+56(FP), R12 |
||||
MOVD R12, (2176+48)(R4) |
||||
MOVD a8+64(FP), R12 |
||||
MOVD R12, (2176+56)(R4) |
||||
MOVD a9+72(FP), R12 |
||||
MOVD R12, (2176+64)(R4) |
||||
|
||||
// Call function. |
||||
LE_CALL |
||||
NOPH |
||||
XOR R0, R0 // Restore R0 to $0. |
||||
MOVD R4, 0(R9) // Save stack pointer. |
||||
|
||||
MOVD R3, r1+80(FP) |
||||
MOVD R0, r2+88(FP) |
||||
MOVD R0, err+96(FP) |
||||
MOVW R3, R4 |
||||
CMP R4, $-1 |
||||
BNE done |
||||
BL addrerrno<>(SB) |
||||
MOVWZ 0(R3), R3 |
||||
MOVD R3, err+96(FP) |
||||
done: |
||||
BL runtime·exitsyscall(SB) |
||||
RET |
||||
|
||||
TEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0 |
||||
MOVD a1+8(FP), R1 |
||||
MOVD a2+16(FP), R2 |
||||
MOVD a3+24(FP), R3 |
||||
|
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get function. |
||||
MOVD CAA(R8), R9 |
||||
MOVD EDCHPXV(R9), R9 |
||||
MOVD trap+0(FP), R5 |
||||
SLD $4, R5 |
||||
ADD R5, R9 |
||||
LMG 0(R9), R5, R6 |
||||
|
||||
// Restore LE stack. |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R4 |
||||
MOVD $0, 0(R9) |
||||
|
||||
// Fill in parameter list. |
||||
MOVD a4+32(FP), R12 |
||||
MOVD R12, (2176+24)(R4) |
||||
MOVD a5+40(FP), R12 |
||||
MOVD R12, (2176+32)(R4) |
||||
MOVD a6+48(FP), R12 |
||||
MOVD R12, (2176+40)(R4) |
||||
MOVD a7+56(FP), R12 |
||||
MOVD R12, (2176+48)(R4) |
||||
MOVD a8+64(FP), R12 |
||||
MOVD R12, (2176+56)(R4) |
||||
MOVD a9+72(FP), R12 |
||||
MOVD R12, (2176+64)(R4) |
||||
|
||||
// Call function. |
||||
LE_CALL |
||||
NOPH |
||||
XOR R0, R0 // Restore R0 to $0. |
||||
MOVD R4, 0(R9) // Save stack pointer. |
||||
|
||||
MOVD R3, r1+80(FP) |
||||
MOVD R0, r2+88(FP) |
||||
MOVD R0, err+96(FP) |
||||
MOVW R3, R4 |
||||
CMP R4, $-1 |
||||
BNE done |
||||
BL addrerrno<>(SB) |
||||
MOVWZ 0(R3), R3 |
||||
MOVD R3, err+96(FP) |
||||
done: |
||||
RET |
||||
|
||||
// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64) |
||||
TEXT ·svcCall(SB),NOSPLIT,$0 |
||||
BL runtime·save_g(SB) // Save g and stack pointer |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD R15, 0(R9) |
||||
|
||||
MOVD argv+8(FP), R1 // Move function arguments into registers |
||||
MOVD dsa+16(FP), g |
||||
MOVD fnptr+0(FP), R15 |
||||
|
||||
BYTE $0x0D // Branch to function |
||||
BYTE $0xEF |
||||
|
||||
BL runtime·load_g(SB) // Restore g and stack pointer |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
MOVD SAVSTACK_ASYNC(R8), R9 |
||||
MOVD 0(R9), R15 |
||||
|
||||
RET |
||||
|
||||
// func svcLoad(name *byte) unsafe.Pointer |
||||
TEXT ·svcLoad(SB),NOSPLIT,$0 |
||||
MOVD R15, R2 // Save go stack pointer |
||||
MOVD name+0(FP), R0 // Move SVC args into registers |
||||
MOVD $0x80000000, R1 |
||||
MOVD $0, R15 |
||||
BYTE $0x0A // SVC 08 LOAD |
||||
BYTE $0x08 |
||||
MOVW R15, R3 // Save return code from SVC |
||||
MOVD R2, R15 // Restore go stack pointer |
||||
CMP R3, $0 // Check SVC return code |
||||
BNE error |
||||
|
||||
MOVD $-2, R3 // Reset last bit of entry point to zero |
||||
AND R0, R3 |
||||
MOVD R3, addr+8(FP) // Return entry point returned by SVC |
||||
CMP R0, R3 // Check if last bit of entry point was set |
||||
BNE done |
||||
|
||||
MOVD R15, R2 // Save go stack pointer |
||||
MOVD $0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08) |
||||
BYTE $0x0A // SVC 09 DELETE |
||||
BYTE $0x09 |
||||
MOVD R2, R15 // Restore go stack pointer |
||||
|
||||
error: |
||||
MOVD $0, addr+8(FP) // Return 0 on failure |
||||
done: |
||||
XOR R0, R0 // Reset r0 to 0 |
||||
RET |
||||
|
||||
// func svcUnload(name *byte, fnptr unsafe.Pointer) int64 |
||||
TEXT ·svcUnload(SB),NOSPLIT,$0 |
||||
MOVD R15, R2 // Save go stack pointer |
||||
MOVD name+0(FP), R0 // Move SVC args into registers |
||||
MOVD addr+8(FP), R15 |
||||
BYTE $0x0A // SVC 09 |
||||
BYTE $0x09 |
||||
XOR R0, R0 // Reset r0 to 0 |
||||
MOVD R15, R1 // Save SVC return code |
||||
MOVD R2, R15 // Restore go stack pointer |
||||
MOVD R1, rc+0(FP) // Return SVC return code |
||||
RET |
||||
|
||||
// func gettid() uint64 |
||||
TEXT ·gettid(SB), NOSPLIT, $0 |
||||
// Get library control area (LCA). |
||||
MOVW PSALAA, R8 |
||||
MOVD LCA64(R8), R8 |
||||
|
||||
// Get CEECAATHDID |
||||
MOVD CAA(R8), R9 |
||||
MOVD 0x3D0(R9), R9 |
||||
MOVD R9, ret+0(FP) |
||||
|
||||
RET |
||||
@ -0,0 +1,36 @@ |
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Bluetooth sockets and messages
|
||||
|
||||
package unix |
||||
|
||||
// Bluetooth Protocols
|
||||
const ( |
||||
BTPROTO_L2CAP = 0 |
||||
BTPROTO_HCI = 1 |
||||
BTPROTO_SCO = 2 |
||||
BTPROTO_RFCOMM = 3 |
||||
BTPROTO_BNEP = 4 |
||||
BTPROTO_CMTP = 5 |
||||
BTPROTO_HIDP = 6 |
||||
BTPROTO_AVDTP = 7 |
||||
) |
||||
|
||||
const ( |
||||
HCI_CHANNEL_RAW = 0 |
||||
HCI_CHANNEL_USER = 1 |
||||
HCI_CHANNEL_MONITOR = 2 |
||||
HCI_CHANNEL_CONTROL = 3 |
||||
HCI_CHANNEL_LOGGING = 4 |
||||
) |
||||
|
||||
// Socketoption Level
|
||||
const ( |
||||
SOL_BLUETOOTH = 0x112 |
||||
SOL_HCI = 0x0 |
||||
SOL_L2CAP = 0x6 |
||||
SOL_RFCOMM = 0x12 |
||||
SOL_SCO = 0x11 |
||||
) |
||||
@ -0,0 +1,196 @@ |
||||
// Copyright 2017 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build freebsd
|
||||
// +build freebsd
|
||||
|
||||
package unix |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
) |
||||
|
||||
// Go implementation of C mostly found in /usr/src/sys/kern/subr_capability.c
|
||||
|
||||
const ( |
||||
// This is the version of CapRights this package understands. See C implementation for parallels.
|
||||
capRightsGoVersion = CAP_RIGHTS_VERSION_00 |
||||
capArSizeMin = CAP_RIGHTS_VERSION_00 + 2 |
||||
capArSizeMax = capRightsGoVersion + 2 |
||||
) |
||||
|
||||
var ( |
||||
bit2idx = []int{ |
||||
-1, 0, 1, -1, 2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, |
||||
4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
||||
} |
||||
) |
||||
|
||||
func capidxbit(right uint64) int { |
||||
return int((right >> 57) & 0x1f) |
||||
} |
||||
|
||||
func rightToIndex(right uint64) (int, error) { |
||||
idx := capidxbit(right) |
||||
if idx < 0 || idx >= len(bit2idx) { |
||||
return -2, fmt.Errorf("index for right 0x%x out of range", right) |
||||
} |
||||
return bit2idx[idx], nil |
||||
} |
||||
|
||||
func caprver(right uint64) int { |
||||
return int(right >> 62) |
||||
} |
||||
|
||||
func capver(rights *CapRights) int { |
||||
return caprver(rights.Rights[0]) |
||||
} |
||||
|
||||
func caparsize(rights *CapRights) int { |
||||
return capver(rights) + 2 |
||||
} |
||||
|
||||
// CapRightsSet sets the permissions in setrights in rights.
|
||||
func CapRightsSet(rights *CapRights, setrights []uint64) error { |
||||
// This is essentially a copy of cap_rights_vset()
|
||||
if capver(rights) != CAP_RIGHTS_VERSION_00 { |
||||
return fmt.Errorf("bad rights version %d", capver(rights)) |
||||
} |
||||
|
||||
n := caparsize(rights) |
||||
if n < capArSizeMin || n > capArSizeMax { |
||||
return errors.New("bad rights size") |
||||
} |
||||
|
||||
for _, right := range setrights { |
||||
if caprver(right) != CAP_RIGHTS_VERSION_00 { |
||||
return errors.New("bad right version") |
||||
} |
||||
i, err := rightToIndex(right) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if i >= n { |
||||
return errors.New("index overflow") |
||||
} |
||||
if capidxbit(rights.Rights[i]) != capidxbit(right) { |
||||
return errors.New("index mismatch") |
||||
} |
||||
rights.Rights[i] |= right |
||||
if capidxbit(rights.Rights[i]) != capidxbit(right) { |
||||
return errors.New("index mismatch (after assign)") |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// CapRightsClear clears the permissions in clearrights from rights.
|
||||
func CapRightsClear(rights *CapRights, clearrights []uint64) error { |
||||
// This is essentially a copy of cap_rights_vclear()
|
||||
if capver(rights) != CAP_RIGHTS_VERSION_00 { |
||||
return fmt.Errorf("bad rights version %d", capver(rights)) |
||||
} |
||||
|
||||
n := caparsize(rights) |
||||
if n < capArSizeMin || n > capArSizeMax { |
||||
return errors.New("bad rights size") |
||||
} |
||||
|
||||
for _, right := range clearrights { |
||||
if caprver(right) != CAP_RIGHTS_VERSION_00 { |
||||
return errors.New("bad right version") |
||||
} |
||||
i, err := rightToIndex(right) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if i >= n { |
||||
return errors.New("index overflow") |
||||
} |
||||
if capidxbit(rights.Rights[i]) != capidxbit(right) { |
||||
return errors.New("index mismatch") |
||||
} |
||||
rights.Rights[i] &= ^(right & 0x01FFFFFFFFFFFFFF) |
||||
if capidxbit(rights.Rights[i]) != capidxbit(right) { |
||||
return errors.New("index mismatch (after assign)") |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// CapRightsIsSet checks whether all the permissions in setrights are present in rights.
|
||||
func CapRightsIsSet(rights *CapRights, setrights []uint64) (bool, error) { |
||||
// This is essentially a copy of cap_rights_is_vset()
|
||||
if capver(rights) != CAP_RIGHTS_VERSION_00 { |
||||
return false, fmt.Errorf("bad rights version %d", capver(rights)) |
||||
} |
||||
|
||||
n := caparsize(rights) |
||||
if n < capArSizeMin || n > capArSizeMax { |
||||
return false, errors.New("bad rights size") |
||||
} |
||||
|
||||
for _, right := range setrights { |
||||
if caprver(right) != CAP_RIGHTS_VERSION_00 { |
||||
return false, errors.New("bad right version") |
||||
} |
||||
i, err := rightToIndex(right) |
||||
if err != nil { |
||||
return false, err |
||||
} |
||||
if i >= n { |
||||
return false, errors.New("index overflow") |
||||
} |
||||
if capidxbit(rights.Rights[i]) != capidxbit(right) { |
||||
return false, errors.New("index mismatch") |
||||
} |
||||
if (rights.Rights[i] & right) != right { |
||||
return false, nil |
||||
} |
||||
} |
||||
|
||||
return true, nil |
||||
} |
||||
|
||||
func capright(idx uint64, bit uint64) uint64 { |
||||
return ((1 << (57 + idx)) | bit) |
||||
} |
||||
|
||||
// CapRightsInit returns a pointer to an initialised CapRights structure filled with rights.
|
||||
// See man cap_rights_init(3) and rights(4).
|
||||
func CapRightsInit(rights []uint64) (*CapRights, error) { |
||||
var r CapRights |
||||
r.Rights[0] = (capRightsGoVersion << 62) | capright(0, 0) |
||||
r.Rights[1] = capright(1, 0) |
||||
|
||||
err := CapRightsSet(&r, rights) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return &r, nil |
||||
} |
||||
|
||||
// CapRightsLimit reduces the operations permitted on fd to at most those contained in rights.
|
||||
// The capability rights on fd can never be increased by CapRightsLimit.
|
||||
// See man cap_rights_limit(2) and rights(4).
|
||||
func CapRightsLimit(fd uintptr, rights *CapRights) error { |
||||
return capRightsLimit(int(fd), rights) |
||||
} |
||||
|
||||
// CapRightsGet returns a CapRights structure containing the operations permitted on fd.
|
||||
// See man cap_rights_get(3) and rights(4).
|
||||
func CapRightsGet(fd uintptr) (*CapRights, error) { |
||||
r, err := CapRightsInit(nil) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
err = capRightsGet(capRightsGoVersion, int(fd), r) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return r, nil |
||||
} |
||||
@ -0,0 +1,14 @@ |
||||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
|
||||
// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
|
||||
|
||||
package unix |
||||
|
||||
const ( |
||||
R_OK = 0x4 |
||||
W_OK = 0x2 |
||||
X_OK = 0x1 |
||||
) |
||||
@ -0,0 +1,27 @@ |
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build aix && ppc
|
||||
// +build aix,ppc
|
||||
|
||||
// Functions to access/create device major and minor numbers matching the
|
||||
// encoding used by AIX.
|
||||
|
||||
package unix |
||||
|
||||
// Major returns the major component of a Linux device number.
|
||||
func Major(dev uint64) uint32 { |
||||
return uint32((dev >> 16) & 0xffff) |
||||
} |
||||
|
||||
// Minor returns the minor component of a Linux device number.
|
||||
func Minor(dev uint64) uint32 { |
||||
return uint32(dev & 0xffff) |
||||
} |
||||
|
||||
// Mkdev returns a Linux device number generated from the given major and minor
|
||||
// components.
|
||||
func Mkdev(major, minor uint32) uint64 { |
||||
return uint64(((major) << 16) | (minor)) |
||||
} |
||||
@ -0,0 +1,29 @@ |
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build aix && ppc64
|
||||
// +build aix,ppc64
|
||||
|
||||
// Functions to access/create device major and minor numbers matching the
|
||||
// encoding used AIX.
|
||||
|
||||
package unix |
||||
|
||||
// Major returns the major component of a Linux device number.
|
||||
func Major(dev uint64) uint32 { |
||||
return uint32((dev & 0x3fffffff00000000) >> 32) |
||||
} |
||||
|
||||
// Minor returns the minor component of a Linux device number.
|
||||
func Minor(dev uint64) uint32 { |
||||
return uint32((dev & 0x00000000ffffffff) >> 0) |
||||
} |
||||
|
||||
// Mkdev returns a Linux device number generated from the given major and minor
|
||||
// components.
|
||||
func Mkdev(major, minor uint32) uint64 { |
||||
var DEVNO64 uint64 |
||||
DEVNO64 = 0x8000000000000000 |
||||
return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64) |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
// Copyright 2017 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Functions to access/create device major and minor numbers matching the
|
||||
// encoding used in Darwin's sys/types.h header.
|
||||
|
||||
package unix |
||||
|
||||
// Major returns the major component of a Darwin device number.
|
||||
func Major(dev uint64) uint32 { |
||||
return uint32((dev >> 24) & 0xff) |
||||
} |
||||
|
||||
// Minor returns the minor component of a Darwin device number.
|
||||
func Minor(dev uint64) uint32 { |
||||
return uint32(dev & 0xffffff) |
||||
} |
||||
|
||||
// Mkdev returns a Darwin device number generated from the given major and minor
|
||||
// components.
|
||||
func Mkdev(major, minor uint32) uint64 { |
||||
return (uint64(major) << 24) | uint64(minor) |
||||
} |
||||
@ -0,0 +1,30 @@ |
||||
// Copyright 2017 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Functions to access/create device major and minor numbers matching the
|
||||
// encoding used in Dragonfly's sys/types.h header.
|
||||
//
|
||||
// The information below is extracted and adapted from sys/types.h:
|
||||
//
|
||||
// Minor gives a cookie instead of an index since in order to avoid changing the
|
||||
// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
|
||||
// devices that don't use them.
|
||||
|
||||
package unix |
||||
|
||||
// Major returns the major component of a DragonFlyBSD device number.
|
||||
func Major(dev uint64) uint32 { |
||||
return uint32((dev >> 8) & 0xff) |
||||
} |
||||
|
||||
// Minor returns the minor component of a DragonFlyBSD device number.
|
||||
func Minor(dev uint64) uint32 { |
||||
return uint32(dev & 0xffff00ff) |
||||
} |
||||
|
||||
// Mkdev returns a DragonFlyBSD device number generated from the given major and
|
||||
// minor components.
|
||||
func Mkdev(major, minor uint32) uint64 { |
||||
return (uint64(major) << 8) | uint64(minor) |
||||
} |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue