func Wrap(f interface{}, args ...interface{}) interface{} {
	return std.WrapWithArgs(f, false, args...)
}
Wrap calls f and then recovers and reports a panic to Rollbar if it occurs.
If an error is captured it is subsequently returned.
package rollbar
import (
	"context"
	"net/http"
	"os"
	"regexp"
	"runtime"
)
const (
	NAME = "rollbar/rollbar-go"
	VERSION = "1.2.0"
	CRIT = "critical"
	ERR = "error"
	WARN = "warning"
	INFO = "info"
	DEBUG = "debug"
	FILTERED = "[FILTERED]"
)
var (
	hostname, _ = os.Hostname()
	std         = NewAsync("", "development", "", hostname, "")
	nilErrTitle = "<nil>"
)
type UnwrapperFunc func(error) error
type StackTracerFunc func(error) ([]runtime.Frame, bool)
var DefaultUnwrapper UnwrapperFunc = func(err error) error {
	type causer interface {
		Cause() error
	}
	type wrapper interface {  
		Unwrap() error
	}
	if e, ok := err.(causer); ok {
		return e.Cause()
	}
	if e, ok := err.(wrapper); ok {
		return e.Unwrap()
	}
	return nil
}
var DefaultStackTracer StackTracerFunc = func(err error) ([]runtime.Frame, bool) {
	if s, ok := err.(Stacker); ok {
		return s.Stack(), true
	}
	return nil, false
}
func SetTelemetry(options ...OptionFunc) {
	std.SetTelemetry(options...)
}
func CaptureTelemetryEvent(eventType, eventlevel string, eventData map[string]interface{}) {
	std.CaptureTelemetryEvent(eventType, eventlevel, eventData)
}
func SetEnabled(enabled bool) {
	std.SetEnabled(enabled)
}
func SetToken(token string) {
	std.SetToken(token)
}
func SetEnvironment(environment string) {
	std.SetEnvironment(environment)
}
func SetEndpoint(endpoint string) {
	std.SetEndpoint(endpoint)
}
func SetItemsPerMinute(itemsPerMinute int) {
	std.SetItemsPerMinute(itemsPerMinute)
}
func SetPlatform(platform string) {
	std.SetPlatform(platform)
}
func SetCodeVersion(codeVersion string) {
	std.SetCodeVersion(codeVersion)
}
func SetServerHost(serverHost string) {
	std.SetServerHost(serverHost)
}
func SetServerRoot(serverRoot string) {
	std.SetServerRoot(serverRoot)
}
func SetCustom(custom map[string]interface{}) {
	std.SetCustom(custom)
}
func SetScrubHeaders(headers *regexp.Regexp) {
	std.SetScrubHeaders(headers)
}
func SetScrubFields(fields *regexp.Regexp) {
	std.SetScrubFields(fields)
}
func SetTransform(transform func(map[string]interface{})) {
	std.SetTransform(transform)
}
func SetUnwrapper(unwrapper UnwrapperFunc) {
	std.SetUnwrapper(unwrapper)
}
func SetStackTracer(stackTracer StackTracerFunc) {
	std.SetStackTracer(stackTracer)
}
func SetCheckIgnore(checkIgnore func(string) bool) {
	std.SetCheckIgnore(checkIgnore)
}
func SetPerson(id, username, email string) {
	std.SetPerson(id, username, email)
}
func ClearPerson() {
	std.ClearPerson()
}
func SetFingerprint(fingerprint bool) {
	std.SetFingerprint(fingerprint)
}
func SetLogger(logger ClientLogger) {
	std.SetLogger(logger)
}
func SetCaptureIp(captureIp captureIp) {
	std.SetCaptureIp(captureIp)
}
func SetRetryAttempts(retryAttempts int) {
	std.SetRetryAttempts(retryAttempts)
}
func SetPrintPayloadOnError(printPayloadOnError bool) {
	std.SetPrintPayloadOnError(printPayloadOnError)
}
func SetHTTPClient(httpClient *http.Client) {
	std.SetHTTPClient(httpClient)
}
func Token() string {
	return std.Token()
}
func Environment() string {
	return std.Environment()
}
func Endpoint() string {
	return std.Endpoint()
}
func Platform() string {
	return std.Platform()
}
func CodeVersion() string {
	return std.CodeVersion()
}
func ServerHost() string {
	return std.ServerHost()
}
func ServerRoot() string {
	return std.ServerRoot()
}
func Custom() map[string]interface{} {
	return std.Custom()
}
func Fingerprint() bool {
	return std.Fingerprint()
}
func CaptureIp() captureIp {
	return std.CaptureIp()
}
func Critical(interfaces ...interface{}) {
	Log(CRIT, interfaces...)
}
func Error(interfaces ...interface{}) {
	Log(ERR, interfaces...)
}
func Warning(interfaces ...interface{}) {
	Log(WARN, interfaces...)
}
func Info(interfaces ...interface{}) {
	Log(INFO, interfaces...)
}
func Debug(interfaces ...interface{}) {
	Log(DEBUG, interfaces...)
}
func Log(level string, interfaces ...interface{}) {
	var r *http.Request
	var err error
	var skip int
	skipSet := false
	var extras map[string]interface{}
	var msg string
	ctx := context.TODO()
	for _, ival := range interfaces {
		switch val := ival.(type) {
		case *http.Request:
			r = val
		case error:
			err = val
		case int:
			skip = val
			skipSet = true
		case string:
			msg = val
		case map[string]interface{}:
			extras = val
		case context.Context:
			ctx = val
		default:
			rollbarError(std.Transport.(*AsyncTransport).Logger, "Unknown input type: %T", val)
		}
	}
	if !skipSet {
		skip = 2
	}
	if err != nil {
		if r == nil {
			std.ErrorWithStackSkipWithExtrasAndContext(ctx, level, err, skip, extras)
		} else {
			std.RequestErrorWithStackSkipWithExtrasAndContext(ctx, level, r, err, skip, extras)
		}
	} else {
		if r == nil {
			std.MessageWithExtrasAndContext(ctx, level, msg, extras)
		} else {
			std.RequestMessageWithExtrasAndContext(ctx, level, r, msg, extras)
		}
	}
}
func ErrorWithLevel(level string, err error) {
	std.ErrorWithLevel(level, err)
}
func Errorf(level string, format string, args ...interface{}) {
	std.Errorf(level, format, args...)
}
func ErrorWithExtras(level string, err error, extras map[string]interface{}) {
	std.ErrorWithExtras(level, err, extras)
}
func ErrorWithExtrasAndContext(ctx context.Context, level string, err error, extras map[string]interface{}) {
	std.ErrorWithExtrasAndContext(ctx, level, err, extras)
}
func RequestError(level string, r *http.Request, err error) {
	std.RequestError(level, r, err)
}
func RequestErrorWithExtras(level string, r *http.Request, err error, extras map[string]interface{}) {
	std.RequestErrorWithExtras(level, r, err, extras)
}
func RequestErrorWithExtrasAndContext(ctx context.Context, level string, r *http.Request, err error, extras map[string]interface{}) {
	std.RequestErrorWithExtrasAndContext(ctx, level, r, err, extras)
}
func ErrorWithStackSkip(level string, err error, skip int) {
	std.ErrorWithStackSkip(level, err, skip)
}
func ErrorWithStackSkipWithExtras(level string, err error, skip int, extras map[string]interface{}) {
	std.ErrorWithStackSkipWithExtras(level, err, skip, extras)
}
func ErrorWithStackSkipWithExtrasAndContext(ctx context.Context, level string, err error, skip int, extras map[string]interface{}) {
	std.ErrorWithStackSkipWithExtrasAndContext(ctx, level, err, skip, extras)
}
func RequestErrorWithStackSkip(level string, r *http.Request, err error, skip int) {
	std.RequestErrorWithStackSkip(level, r, err, skip)
}
func RequestErrorWithStackSkipWithExtras(level string, r *http.Request, err error, skip int, extras map[string]interface{}) {
	std.RequestErrorWithStackSkipWithExtras(level, r, err, skip, extras)
}
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)
}
func Message(level string, msg string) {
	std.Message(level, msg)
}
func MessageWithExtras(level string, msg string, extras map[string]interface{}) {
	std.MessageWithExtras(level, msg, extras)
}
func MessageWithExtrasAndContext(ctx context.Context, level string, msg string, extras map[string]interface{}) {
	std.MessageWithExtrasAndContext(ctx, level, msg, extras)
}
func RequestMessage(level string, r *http.Request, msg string) {
	std.RequestMessage(level, r, msg)
}
func RequestMessageWithExtras(level string, r *http.Request, msg string, extras map[string]interface{}) {
	std.RequestMessageWithExtras(level, r, msg, extras)
}
func RequestMessageWithExtrasAndContext(ctx context.Context, level string, r *http.Request, msg string, extras map[string]interface{}) {
	std.RequestMessageWithExtrasAndContext(ctx, level, r, msg, extras)
}
func Wait() {
	std.Wait()
}
func Close() {
	std.Close()
}
func LogPanic(err interface{}, wait bool) {
	std.LogPanic(err, wait)
}
func WrapWithArgs(f interface{}, wait bool, args ...interface{}) interface{} {
	return std.WrapWithArgs(f, wait, args...)
}