_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q13700 | Indeterminate | train | func (p ProgressDisplayFunc) Indeterminate() []string {
// loop through until we get back to the first string
set := []string{p(-1)}
for {
next := p(-1)
if next == set[0] {
break
}
set = append(set, next)
}
return set
} | go | {
"resource": ""
} |
q13701 | Set | train | func (c *contextValues) Set(key string, value interface{}) {
if *c == nil {
*c = make(map[string]interface{})
}
(*c)[key] = value
} | go | {
"resource": ""
} |
q13702 | Keys | train | func (c contextValues) Keys() (keys []string) {
for key := range c {
keys = append(keys, key)
}
return
} | go | {
"resource": ""
} |
q13703 | rlPrompt | train | func (s *shellReader) rlPrompt() string {
if s.showPrompt {
if s.readingMulti {
return s.multiPrompt
}
return s.prompt
}
return ""
} | go | {
"resource": ""
} |
q13704 | Push | train | func (his *MemoryHistory) Push(p *State) int {
his.list.PushFront(p)
// Trim history if maxHist is set
if his.maxHist > 0 {
if l := his.list.Len(); l > his.maxHist {
for i := 0; i < l-his.maxHist; i++ {
his.list.Remove(his.list.Back())
}
}
}
return his.list.Len()
} | go | {
"resource": ""
} |
q13705 | Pop | train | func (his *MemoryHistory) Pop() *State {
if his.list.Len() > 0 {
return his.list.Remove(his.list.Front()).(*State)
}
return nil
} | go | {
"resource": ""
} |
q13706 | Top | train | func (his *MemoryHistory) Top() *State {
if his.list.Len() == 0 {
return nil
}
return his.list.Front().Value.(*State)
} | go | {
"resource": ""
} |
q13707 | Has | train | func (b *MemoryBookmarks) Has(name string) bool {
_, ok := b.bookmarks[name]
return ok
} | go | {
"resource": ""
} |
q13708 | writeToFile | train | func (b *FileBookmarks) writeToFile() (err error) {
j, err := json.Marshal(b.bookmarks)
if err != nil {
return err
}
fout, err := os.Create(b.file)
if err != nil {
return err
}
defer func() {
err = fout.Close()
}()
_, err = fout.Write(j)
if err != nil {
return err
}
return err
} | go | {
"resource": ""
} |
q13709 | Download | train | func (at *DownloadableAsset) Download(out io.Writer) (int64, error) {
return DownloadAsset(at, out)
} | go | {
"resource": ""
} |
q13710 | DownloadAsync | train | func (at *DownloadableAsset) DownloadAsync(out io.Writer, ch AsyncDownloadChannel) {
DownloadAssetAsync(at, out, ch)
} | go | {
"resource": ""
} |
q13711 | DownloadAsset | train | func DownloadAsset(asset Downloadable, out io.Writer) (int64, error) {
resp, err := http.Get(asset.Url().String())
if err != nil {
return 0, err
}
defer resp.Body.Close()
return io.Copy(out, resp.Body)
} | go | {
"resource": ""
} |
q13712 | DownloadAssetAsync | train | func DownloadAssetAsync(asset Downloadable, out io.Writer, c AsyncDownloadChannel) {
go func() {
results := &AsyncDownloadResult{Asset: asset, Writer: out}
size, err := DownloadAsset(asset, out)
if err != nil {
results.Error = err
} else {
results.Size = size
}
c <- results
}()
} | go | {
"resource": ""
} |
q13713 | New | train | func New(msg string, a ...interface{}) Error {
msg = fmt.Sprintf(msg, a...)
return Error{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13714 | NewPageNotFound | train | func NewPageNotFound(msg string, a ...interface{}) PageNotFound {
msg = fmt.Sprintf("Not Found: "+msg, a...)
return PageNotFound{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13715 | NewLinkNotFound | train | func NewLinkNotFound(msg string, a ...interface{}) LinkNotFound {
msg = fmt.Sprintf("Link Not Found: "+msg, a...)
return LinkNotFound{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13716 | NewAttributeNotFound | train | func NewAttributeNotFound(msg string, a ...interface{}) AttributeNotFound {
msg = fmt.Sprintf(msg, a...)
return AttributeNotFound{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13717 | NewLocation | train | func NewLocation(msg string, a ...interface{}) Location {
msg = fmt.Sprintf(msg, a...)
return Location{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13718 | NewPageNotLoaded | train | func NewPageNotLoaded(msg string, a ...interface{}) PageNotLoaded {
msg = fmt.Sprintf("Page Not Loaded: "+msg, a...)
return PageNotLoaded{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13719 | NewElementNotFound | train | func NewElementNotFound(msg string, a ...interface{}) ElementNotFound {
msg = fmt.Sprintf(msg, a...)
return ElementNotFound{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13720 | NewInvalidFormValue | train | func NewInvalidFormValue(msg string, a ...interface{}) InvalidFormValue {
msg = fmt.Sprintf(msg, a...)
return InvalidFormValue{
error: errors.New(msg),
}
} | go | {
"resource": ""
} |
q13721 | Input | train | func (f *Form) Input(name, value string) error {
if _, ok := f.fields[name]; ok {
f.fields.Set(name, value)
return nil
}
return errors.NewElementNotFound("No input found with name '%s'.", name)
} | go | {
"resource": ""
} |
q13722 | File | train | func (f *Form) File(name string, fileName string, data io.Reader) error {
if _, ok := f.files[name]; ok {
f.files[name] = &File{fileName: fileName, data: data}
return nil
}
return errors.NewElementNotFound(
"No input type 'file' found with name '%s'.", name)
} | go | {
"resource": ""
} |
q13723 | SetFile | train | func (f *Form) SetFile(name string, fileName string, data io.Reader) {
f.files[name] = &File{fileName: fileName, data: data}
} | go | {
"resource": ""
} |
q13724 | Check | train | func (f *Form) Check(name string) error {
if _, ok := f.checkboxs[name]; ok {
f.fields.Set(name, f.checkboxs.Get(name))
return nil
}
return errors.NewElementNotFound("No checkbox found with name '%s'.", name)
} | go | {
"resource": ""
} |
q13725 | UnCheck | train | func (f *Form) UnCheck(name string) error {
if _, ok := f.checkboxs[name]; ok {
f.fields.Del(name)
return nil
}
return errors.NewElementNotFound("No checkbox found with name '%s'.", name)
} | go | {
"resource": ""
} |
q13726 | IsChecked | train | func (f *Form) IsChecked(name string) (bool, error) {
if _, ok := f.checkboxs[name]; ok {
_, found := f.fields[name]
return found, nil
}
return false, errors.NewElementNotFound("No checkbox found with name '%s'.", name)
} | go | {
"resource": ""
} |
q13727 | Value | train | func (f *Form) Value(name string) (string, error) {
if _, ok := f.fields[name]; ok {
return f.fields.Get(name), nil
}
return "", errors.NewElementNotFound("No input found with name '%s'.", name)
} | go | {
"resource": ""
} |
q13728 | RemoveValue | train | func (f *Form) RemoveValue(name, val string) error {
if _, ok := f.fields[name]; !ok {
return errors.NewElementNotFound("No input found with name '%s'.", name)
}
var save []string
for _, v := range f.fields[name] {
if v != val {
save = append(save, v)
}
}
if len(save) == 0 {
f.fields.Del(name)
} else {
f.fields[name] = save
}
return nil
} | go | {
"resource": ""
} |
q13729 | SelectByOptionLabel | train | func (f *Form) SelectByOptionLabel(name string, optionLabel ...string) error {
s, ok := f.selects[name]
if !ok {
return errors.NewElementNotFound("No select element found with name '%s'.", name)
}
if len(optionLabel) > 1 && !s.multiple {
return errors.NewElementNotFound("The select element with name '%s' is not a select miltiple.", name)
}
f.fields.Del(name)
for _, l := range optionLabel {
if _, ok := s.labels[l]; !ok {
return errors.NewElementNotFound("The select element with name %q does not have an option with label %q", name, l)
}
f.fields.Add(name, s.labels.Get(l))
}
return nil
} | go | {
"resource": ""
} |
q13730 | SelectByOptionValue | train | func (f *Form) SelectByOptionValue(name string, optionValue ...string) error {
s, ok := f.selects[name]
if !ok {
return errors.NewElementNotFound("No select element found with name '%s'.", name)
}
if len(optionValue) > 1 && !s.multiple {
return errors.NewElementNotFound("The select element with name '%s' is not a select miltiple.", name)
}
f.fields.Del(name)
for _, v := range optionValue {
if _, ok := s.values[v]; !ok {
return errors.NewElementNotFound("The select element with name %q does not have an option with value %q", name, v)
}
f.fields.Add(name, v)
}
return nil
} | go | {
"resource": ""
} |
q13731 | SelectValues | train | func (f *Form) SelectValues(name string) ([]string, error) {
if _, ok := f.fields[name]; ok {
return f.fields[name], nil
}
return nil, errors.NewElementNotFound("No input found with name '%s'.", name)
} | go | {
"resource": ""
} |
q13732 | SelectLabels | train | func (f *Form) SelectLabels(name string) ([]string, error) {
s, ok := f.selects[name]
if !ok {
return nil, errors.NewElementNotFound("No select element found with name '%s'.", name)
}
var labels []string
for _, v := range f.fields[name] {
labels = append(labels, s.values.Get(v))
}
return labels, nil
} | go | {
"resource": ""
} |
q13733 | ClickByValue | train | func (f *Form) ClickByValue(name, value string) error {
if _, ok := f.buttons[name]; !ok {
return errors.NewInvalidFormValue(
"Form does not contain a button with the name '%s'.", name)
}
valueNotFound := true
for _, val := range f.buttons[name] {
if val == value {
valueNotFound = false
break
}
}
if valueNotFound {
return errors.NewInvalidFormValue(
"Form does not contain a button with the name '%s' and value '%s'.", name, value)
}
return f.send(name, value)
} | go | {
"resource": ""
} |
q13734 | Open | train | func (bow *Browser) Open(u string) error {
ur, err := url.Parse(u)
if err != nil {
return err
}
return bow.httpGET(ur, nil)
} | go | {
"resource": ""
} |
q13735 | Head | train | func (bow *Browser) Head(u string) error {
ur, err := url.Parse(u)
if err != nil {
return err
}
return bow.httpHEAD(ur, nil)
} | go | {
"resource": ""
} |
q13736 | OpenForm | train | func (bow *Browser) OpenForm(u string, data url.Values) error {
ul, err := url.Parse(u)
if err != nil {
return err
}
ul.RawQuery = data.Encode()
return bow.Open(ul.String())
} | go | {
"resource": ""
} |
q13737 | Post | train | func (bow *Browser) Post(u string, contentType string, body io.Reader) error {
ur, err := url.Parse(u)
if err != nil {
return err
}
return bow.httpPOST(ur, bow.Url(), contentType, body)
} | go | {
"resource": ""
} |
q13738 | PostForm | train | func (bow *Browser) PostForm(u string, data url.Values) error {
return bow.Post(u, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
} | go | {
"resource": ""
} |
q13739 | Back | train | func (bow *Browser) Back() bool {
if bow.history.Len() > 1 {
bow.state = bow.history.Pop()
return true
}
return false
} | go | {
"resource": ""
} |
q13740 | Reload | train | func (bow *Browser) Reload() error {
if bow.state.Request != nil {
return bow.httpRequest(bow.state.Request)
}
return errors.NewPageNotLoaded("Cannot reload, the previous request failed.")
} | go | {
"resource": ""
} |
q13741 | Bookmark | train | func (bow *Browser) Bookmark(name string) error {
return bow.bookmarks.Save(name, bow.ResolveUrl(bow.Url()).String())
} | go | {
"resource": ""
} |
q13742 | Click | train | func (bow *Browser) Click(expr string) error {
sel := bow.Find(expr)
if sel.Length() == 0 {
return errors.NewElementNotFound(
"Element not found matching expr '%s'.", expr)
}
if !sel.Is("a") {
return errors.NewElementNotFound(
"Expr '%s' must match an anchor tag.", expr)
}
href, err := bow.attrToResolvedUrl("href", sel)
if err != nil {
return err
}
return bow.httpGET(href, bow.Url())
} | go | {
"resource": ""
} |
q13743 | Form | train | func (bow *Browser) Form(expr string) (Submittable, error) {
sel := bow.Find(expr)
if sel.Length() == 0 {
return nil, errors.NewElementNotFound(
"Form not found matching expr '%s'.", expr)
}
if !sel.Is("form") {
return nil, errors.NewElementNotFound(
"Expr '%s' does not match a form tag.", expr)
}
return NewForm(bow, sel), nil
} | go | {
"resource": ""
} |
q13744 | Forms | train | func (bow *Browser) Forms() []Submittable {
sel := bow.Find("form")
len := sel.Length()
if len == 0 {
return nil
}
forms := make([]Submittable, len)
sel.Each(func(_ int, s *goquery.Selection) {
forms = append(forms, NewForm(bow, s))
})
return forms
} | go | {
"resource": ""
} |
q13745 | Links | train | func (bow *Browser) Links() []*Link {
links := make([]*Link, 0, InitialAssetsSliceSize)
bow.Find("a").Each(func(_ int, s *goquery.Selection) {
href, err := bow.attrToResolvedUrl("href", s)
if err == nil {
links = append(links, NewLinkAsset(
href,
bow.attrOrDefault("id", "", s),
s.Text(),
))
}
})
return links
} | go | {
"resource": ""
} |
q13746 | Images | train | func (bow *Browser) Images() []*Image {
images := make([]*Image, 0, InitialAssetsSliceSize)
bow.Find("img").Each(func(_ int, s *goquery.Selection) {
src, err := bow.attrToResolvedUrl("src", s)
if err == nil {
images = append(images, NewImageAsset(
src,
bow.attrOrDefault("id", "", s),
bow.attrOrDefault("alt", "", s),
bow.attrOrDefault("title", "", s),
))
}
})
return images
} | go | {
"resource": ""
} |
q13747 | Stylesheets | train | func (bow *Browser) Stylesheets() []*Stylesheet {
stylesheets := make([]*Stylesheet, 0, InitialAssetsSliceSize)
bow.Find("link").Each(func(_ int, s *goquery.Selection) {
rel, ok := s.Attr("rel")
if ok && rel == "stylesheet" {
href, err := bow.attrToResolvedUrl("href", s)
if err == nil {
stylesheets = append(stylesheets, NewStylesheetAsset(
href,
bow.attrOrDefault("id", "", s),
bow.attrOrDefault("media", "all", s),
bow.attrOrDefault("type", "text/css", s),
))
}
}
})
return stylesheets
} | go | {
"resource": ""
} |
q13748 | Scripts | train | func (bow *Browser) Scripts() []*Script {
scripts := make([]*Script, 0, InitialAssetsSliceSize)
bow.Find("script").Each(func(_ int, s *goquery.Selection) {
src, err := bow.attrToResolvedUrl("src", s)
if err == nil {
scripts = append(scripts, NewScriptAsset(
src,
bow.attrOrDefault("id", "", s),
bow.attrOrDefault("type", "text/javascript", s),
))
}
})
return scripts
} | go | {
"resource": ""
} |
q13749 | SiteCookies | train | func (bow *Browser) SiteCookies() []*http.Cookie {
if bow.client == nil {
bow.client = bow.buildClient()
}
return bow.client.Jar.Cookies(bow.Url())
} | go | {
"resource": ""
} |
q13750 | SetCookieJar | train | func (bow *Browser) SetCookieJar(cj http.CookieJar) {
if bow.client == nil {
bow.client = bow.buildClient()
}
bow.client.Jar = cj
} | go | {
"resource": ""
} |
q13751 | SetAttribute | train | func (bow *Browser) SetAttribute(a Attribute, v bool) {
bow.attributes[a] = v
} | go | {
"resource": ""
} |
q13752 | SetTimeout | train | func (bow *Browser) SetTimeout(t time.Duration) {
if bow.client == nil {
bow.client = bow.buildClient()
}
bow.client.Timeout = t
} | go | {
"resource": ""
} |
q13753 | SetTransport | train | func (bow *Browser) SetTransport(rt http.RoundTripper) {
if bow.client == nil {
bow.client = bow.buildClient()
}
bow.client.Transport = rt
} | go | {
"resource": ""
} |
q13754 | AddRequestHeader | train | func (bow *Browser) AddRequestHeader(name, value string) {
bow.headers.Set(name, value)
} | go | {
"resource": ""
} |
q13755 | ResolveUrl | train | func (bow *Browser) ResolveUrl(u *url.URL) *url.URL {
return bow.Url().ResolveReference(u)
} | go | {
"resource": ""
} |
q13756 | ResolveStringUrl | train | func (bow *Browser) ResolveStringUrl(u string) (string, error) {
pu, err := url.Parse(u)
if err != nil {
return "", err
}
pu = bow.Url().ResolveReference(pu)
return pu.String(), nil
} | go | {
"resource": ""
} |
q13757 | Download | train | func (bow *Browser) Download(o io.Writer) (int64, error) {
buff := bytes.NewBuffer(bow.body)
return io.Copy(o, buff)
} | go | {
"resource": ""
} |
q13758 | Url | train | func (bow *Browser) Url() *url.URL {
if bow.state.Response == nil {
// there is a possibility that we issued a request, but for
// whatever reason the request failed.
if bow.state.Request != nil {
return bow.state.Request.URL
}
return nil
}
return bow.state.Response.Request.URL
} | go | {
"resource": ""
} |
q13759 | Body | train | func (bow *Browser) Body() string {
body, _ := bow.state.Dom.Find("body").Html()
return body
} | go | {
"resource": ""
} |
q13760 | Find | train | func (bow *Browser) Find(expr string) *goquery.Selection {
return bow.state.Dom.Find(expr)
} | go | {
"resource": ""
} |
q13761 | httpGET | train | func (bow *Browser) httpGET(u *url.URL, ref *url.URL) error {
req, err := bow.buildRequest("GET", u.String(), ref, nil)
if err != nil {
return err
}
return bow.httpRequest(req)
} | go | {
"resource": ""
} |
q13762 | httpPOST | train | func (bow *Browser) httpPOST(u *url.URL, ref *url.URL, contentType string, body io.Reader) error {
req, err := bow.buildRequest("POST", u.String(), ref, body)
if err != nil {
return err
}
req.Header.Set("Content-Type", contentType)
return bow.httpRequest(req)
} | go | {
"resource": ""
} |
q13763 | postSend | train | func (bow *Browser) postSend() {
if isContentTypeHtml(bow.state.Response) && bow.attributes[MetaRefreshHandling] {
sel := bow.Find("meta[http-equiv='refresh']")
if sel.Length() > 0 {
attr, ok := sel.Attr("content")
if ok {
dur, err := time.ParseDuration(attr + "s")
if err == nil {
bow.refresh = time.NewTimer(dur)
go func() {
<-bow.refresh.C
bow.Reload()
}()
}
}
}
}
} | go | {
"resource": ""
} |
q13764 | shouldRedirect | train | func (bow *Browser) shouldRedirect(req *http.Request, _ []*http.Request) error {
if bow.attributes[FollowRedirects] {
req.Header.Set("User-Agent", bow.userAgent)
return nil
}
return errors.NewLocation(
"Redirects are disabled. Cannot follow '%s'.", req.URL.String())
} | go | {
"resource": ""
} |
q13765 | attrToResolvedUrl | train | func (bow *Browser) attrToResolvedUrl(name string, sel *goquery.Selection) (*url.URL, error) {
src, ok := sel.Attr(name)
if !ok {
return nil, errors.NewAttributeNotFound(
"Attribute '%s' not found.", name)
}
ur, err := url.Parse(src)
if err != nil {
return nil, err
}
return bow.ResolveUrl(ur), nil
} | go | {
"resource": ""
} |
q13766 | attrOrDefault | train | func (bow *Browser) attrOrDefault(name, def string, sel *goquery.Selection) string {
a, ok := sel.Attr(name)
if ok {
return a
}
return def
} | go | {
"resource": ""
} |
q13767 | PKCS5Padding | train | func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
padding := blockSize - len(ciphertext)%blockSize
if padding < 0 {
padding = 0
}
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padtext...)
} | go | {
"resource": ""
} |
q13768 | PKCS5UnPadding | train | func PKCS5UnPadding(plaintext []byte) []byte {
length := len(plaintext)
if length <= 0 {
return nil
}
unpadding := int(plaintext[length-1])
if length-unpadding < 0 {
return nil
}
return plaintext[:(length - unpadding)]
} | go | {
"resource": ""
} |
q13769 | Errorf | train | func Errorf(level string, format string, args ...interface{}) {
std.Errorf(level, format, args...)
} | go | {
"resource": ""
} |
q13770 | ErrorWithExtras | train | func ErrorWithExtras(level string, err error, extras map[string]interface{}) {
std.ErrorWithExtras(level, err, extras)
} | go | {
"resource": ""
} |
q13771 | ErrorWithExtrasAndContext | train | func ErrorWithExtrasAndContext(ctx context.Context, level string, err error, extras map[string]interface{}) {
std.ErrorWithExtrasAndContext(ctx, level, err, extras)
} | go | {
"resource": ""
} |
q13772 | RequestError | train | func RequestError(level string, r *http.Request, err error) {
std.RequestError(level, r, err)
} | go | {
"resource": ""
} |
q13773 | RequestErrorWithExtras | train | func RequestErrorWithExtras(level string, r *http.Request, err error, extras map[string]interface{}) {
std.RequestErrorWithExtras(level, r, err, extras)
} | go | {
"resource": ""
} |
q13774 | RequestErrorWithExtrasAndContext | train | func RequestErrorWithExtrasAndContext(ctx context.Context, level string, r *http.Request, err error, extras map[string]interface{}) {
std.RequestErrorWithExtrasAndContext(ctx, level, r, err, extras)
} | go | {
"resource": ""
} |
q13775 | ErrorWithStackSkip | train | func ErrorWithStackSkip(level string, err error, skip int) {
std.ErrorWithStackSkip(level, err, skip)
} | go | {
"resource": ""
} |
q13776 | ErrorWithStackSkipWithExtras | train | func ErrorWithStackSkipWithExtras(level string, err error, skip int, extras map[string]interface{}) {
std.ErrorWithStackSkipWithExtras(level, err, skip, extras)
} | go | {
"resource": ""
} |
q13777 | ErrorWithStackSkipWithExtrasAndContext | train | func ErrorWithStackSkipWithExtrasAndContext(ctx context.Context, level string, err error, skip int, extras map[string]interface{}) {
std.ErrorWithStackSkipWithExtrasAndContext(ctx, level, err, skip, extras)
} | go | {
"resource": ""
} |
q13778 | RequestErrorWithStackSkip | train | func RequestErrorWithStackSkip(level string, r *http.Request, err error, skip int) {
std.RequestErrorWithStackSkip(level, r, err, skip)
} | go | {
"resource": ""
} |
q13779 | RequestErrorWithStackSkipWithExtras | train | func RequestErrorWithStackSkipWithExtras(level string, r *http.Request, err error, skip int, extras map[string]interface{}) {
std.RequestErrorWithStackSkipWithExtras(level, r, err, skip, extras)
} | go | {
"resource": ""
} |
q13780 | RequestErrorWithStackSkipWithExtrasAndContext | train | func RequestErrorWithStackSkipWithExtrasAndContext(ctx context.Context, level string, r *http.Request, err error, skip int, extras map[string]interface{}) {
std.RequestErrorWithStackSkipWithExtrasAndContext(ctx, level, r, err, skip, extras)
} | go | {
"resource": ""
} |
q13781 | MessageWithExtras | train | func MessageWithExtras(level string, msg string, extras map[string]interface{}) {
std.MessageWithExtras(level, msg, extras)
} | go | {
"resource": ""
} |
q13782 | MessageWithExtrasAndContext | train | func MessageWithExtrasAndContext(ctx context.Context, level string, msg string, extras map[string]interface{}) {
std.MessageWithExtrasAndContext(ctx, level, msg, extras)
} | go | {
"resource": ""
} |
q13783 | RequestMessage | train | func RequestMessage(level string, r *http.Request, msg string) {
std.RequestMessage(level, r, msg)
} | go | {
"resource": ""
} |
q13784 | RequestMessageWithExtras | train | func RequestMessageWithExtras(level string, r *http.Request, msg string, extras map[string]interface{}) {
std.RequestMessageWithExtras(level, r, msg, extras)
} | go | {
"resource": ""
} |
q13785 | RequestMessageWithExtrasAndContext | train | func RequestMessageWithExtrasAndContext(ctx context.Context, level string, r *http.Request, msg string, extras map[string]interface{}) {
std.RequestMessageWithExtrasAndContext(ctx, level, r, msg, extras)
} | go | {
"resource": ""
} |
q13786 | remoteIP | train | func remoteIP(req *http.Request) string {
realIP := req.Header.Get("X-Real-IP")
if realIP != "" {
return realIP
}
forwardedIPs := req.Header.Get("X-Forwarded-For")
if forwardedIPs != "" {
ips := strings.Split(forwardedIPs, ", ")
return ips[0]
}
return req.RemoteAddr
} | go | {
"resource": ""
} |
q13787 | filterFlatten | train | func filterFlatten(pattern *regexp.Regexp, values map[string][]string, specialKeys map[string]struct{}) map[string]interface{} {
result := make(map[string]interface{})
for k, v := range values {
switch _, special := specialKeys[k]; {
case pattern.Match([]byte(k)):
result[k] = FILTERED
case special || len(v) == 1:
result[k] = v[0]
default:
result[k] = v
}
}
return result
} | go | {
"resource": ""
} |
q13788 | flattenValues | train | func flattenValues(values map[string][]string) map[string]interface{} {
result := make(map[string]interface{})
for k, v := range values {
if len(v) == 1 {
result[k] = v[0]
} else {
result[k] = v
}
}
return result
} | go | {
"resource": ""
} |
q13789 | filterIp | train | func filterIp(ip string, captureIp captureIp) string {
switch captureIp {
case CaptureIpFull:
return ip
case CaptureIpAnonymize:
if strings.Contains(ip, ".") {
parts := strings.Split(ip, ".")
parts[len(parts)-1] = "0"
return strings.Join(parts, ".")
}
if strings.Contains(ip, ":") {
parts := strings.Split(ip, ":")
if len(parts) > 2 {
parts = parts[0:3]
parts = append(parts, "0000:0000:0000:0000:0000")
return strings.Join(parts, ":")
}
return ip
}
return ip
case CaptureIpNone:
return ""
default:
return ""
}
} | go | {
"resource": ""
} |
q13790 | errorBody | train | func errorBody(configuration configuration, err error, skip int) (map[string]interface{}, string) {
var parent error
// allocate the slice at all times since it will get marshaled into JSON later
traceChain := []map[string]interface{}{}
fingerprint := ""
for {
stack := buildStack(getOrBuildFrames(err, parent, 1+skip))
traceChain = append(traceChain, buildTrace(err, stack))
if configuration.fingerprint {
fingerprint = fingerprint + stack.Fingerprint()
}
parent = err
err = getCause(err)
if err == nil {
break
}
}
errBody := map[string]interface{}{"trace_chain": traceChain}
return errBody, fingerprint
} | go | {
"resource": ""
} |
q13791 | buildTrace | train | func buildTrace(err error, stack stack) map[string]interface{} {
message := nilErrTitle
if err != nil {
message = err.Error()
}
return map[string]interface{}{
"frames": stack,
"exception": map[string]interface{}{
"class": errorClass(err),
"message": message,
},
}
} | go | {
"resource": ""
} |
q13792 | getOrBuildFrames | train | func getOrBuildFrames(err error, parent error, skip int) []runtime.Frame {
if cs, ok := err.(CauseStacker); ok {
return cs.Stack()
} else if _, ok := parent.(CauseStacker); !ok {
return getCallersFrames(1 + skip)
}
return nil
} | go | {
"resource": ""
} |
q13793 | NewSyncTransport | train | func NewSyncTransport(token, endpoint string) *SyncTransport {
return &SyncTransport{
Token: token,
Endpoint: endpoint,
RetryAttempts: DefaultRetryAttempts,
PrintPayloadOnError: true,
}
} | go | {
"resource": ""
} |
q13794 | Send | train | func (t *SyncTransport) Send(body map[string]interface{}) error {
return t.doSend(body, t.RetryAttempts)
} | go | {
"resource": ""
} |
q13795 | New | train | func New(token, environment, codeVersion, serverHost, serverRoot string) *Client {
return NewAsync(token, environment, codeVersion, serverHost, serverRoot)
} | go | {
"resource": ""
} |
q13796 | NewAsync | train | func NewAsync(token, environment, codeVersion, serverHost, serverRoot string) *Client {
configuration := createConfiguration(token, environment, codeVersion, serverHost, serverRoot)
transport := NewTransport(token, configuration.endpoint)
return &Client{
Transport: transport,
configuration: configuration,
}
} | go | {
"resource": ""
} |
q13797 | NewSync | train | func NewSync(token, environment, codeVersion, serverHost, serverRoot string) *Client {
configuration := createConfiguration(token, environment, codeVersion, serverHost, serverRoot)
transport := NewSyncTransport(token, configuration.endpoint)
return &Client{
Transport: transport,
configuration: configuration,
}
} | go | {
"resource": ""
} |
q13798 | SetToken | train | func (c *Client) SetToken(token string) {
c.configuration.token = token
c.Transport.SetToken(token)
} | go | {
"resource": ""
} |
q13799 | SetEndpoint | train | func (c *Client) SetEndpoint(endpoint string) {
c.configuration.endpoint = endpoint
c.Transport.SetEndpoint(endpoint)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.