Logging 支持Loggly中的非英语字符

我正在尝试将web应用程序收集的数据记录到。然而，在提交包含俄语或希伯来语字符串的JSON（甚至纯文本）后，我在输出时收到问号

包含俄语单词的字符串示例：

curl -H "content-type:text/plain" -d "Привет, мир!" https://logs.loggly.com/inputs/YOUR-INPUT-GOES-HERE

---

Loggly中是否支持非英语字符？如果是，我如何利用它？我很确定我是以UTF-8的形式发送数据。

我自己还没有使用loggly，所以这只是一个猜测：需要指定content type标头中的字符集：

Content-Type: text/plain; charset=utf-8

---

否则它可能默认为ascii。

我自己还没有使用loggly，所以这只是一个猜测：需要指定content type标头中的字符集：

Content-Type: text/plain; charset=utf-8

---

否则它可能默认为ascii。

显然，令人惊讶的是，似乎只支持ascii（0-127）字符：

我们只索引属于ASCII的ASCII和UTF-8（如果它们不属于这两类，数据将显示为？）。给您带来不便，我深表歉意

---

来源：

显然，令人惊讶的是，似乎只支持ASCII（0-127）字符：

我们只索引属于ASCII的ASCII和UTF-8（如果它们不属于这两类，数据将显示为？）。给您带来不便，我深表歉意

---

来源：

查看此问题的解决方案

import { Injectable } from '@angular/core';

@Injectable()
export class Loggly {
  private LTracker: any;

  constructor() {

    this.LTracker = this.LTrack(window, document) || [];
    this.LTracker.push({
      'logglyKey': 'YOUR_KEY_HERE',
      'sendConsoleErrors' : true,
      'tag' : 'loggly-jslogger'
    });
  }

  push(props) {
    this.LTracker.push(props);
  }

  LTrack (window, document) {
    var LOGGLY_INPUT_PREFIX = 'http' + (('https:' === document.location.protocol ? 's' : '')) + '://',
      LOGGLY_COLLECTOR_DOMAIN = 'logs-01.loggly.com',
      LOGGLY_SESSION_KEY = 'logglytrackingsession',
      LOGGLY_SESSION_KEY_LENGTH = LOGGLY_SESSION_KEY.length + 1,
      LOGGLY_PROXY_DOMAIN = 'loggly';

    function uuid() {
      // lifted from here -> http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
      return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
      });
    }

    function LogglyTracker() {
      this.key = false;
      this.sendConsoleErrors = false;
      this.tag = 'jslogger';
      this.useDomainProxy = false;
    }

    function setKey(tracker, key) {
      tracker.key = key;
      tracker.setSession();
      setInputUrl(tracker);
    }

    function setTag(tracker, tag) {
      tracker.tag = tag;
    }

    function setDomainProxy(tracker, useDomainProxy) {
      tracker.useDomainProxy = useDomainProxy;
      //refresh inputUrl value
      setInputUrl(tracker);
    }

    function setSendConsoleError(tracker, sendConsoleErrors) {
      tracker.sendConsoleErrors = sendConsoleErrors;

      if (tracker.sendConsoleErrors === true) {
        var _onerror = window.onerror;
        //send console error messages to Loggly
        window.onerror = function (msg, url, line, col, err){
          tracker.push({
            category: 'BrowserJsException',
            exception: {
              message: msg,
              url: url,
              lineno: line,
              colno: col,
              stack: err ? err.stack : 'n/a',
            }
          });

          if (_onerror && typeof _onerror === 'function') {
            _onerror.apply(window, arguments);
          }
        };
      }
    }

    function setInputUrl(tracker) {

      if (tracker.useDomainProxy == true) {
        tracker.inputUrl = LOGGLY_INPUT_PREFIX
          + window.location.host
          + '/'
          + LOGGLY_PROXY_DOMAIN
          + '/inputs/'
          + tracker.key
          + '/tag/'
          + tracker.tag;
      }
      else {
        tracker.inputUrl = LOGGLY_INPUT_PREFIX
          + (tracker.logglyCollectorDomain || LOGGLY_COLLECTOR_DOMAIN)
          + '/inputs/'
          + tracker.key
          + '/tag/'
          + tracker.tag;
      }
    }

    LogglyTracker.prototype = {
      setSession: function (session_id) {
        if (session_id) {
          this.session_id = session_id;
          this.setCookie(this.session_id);
        } else if (!this.session_id) {
          this.session_id = this.readCookie();
          if (!this.session_id) {
            this.session_id = uuid();
            this.setCookie(this.session_id);
          }
        }
      },
      push: function (data) {
        var type = typeof data;

        if (!data || !(type === 'object' || type === 'string')) {
          return;
        }

        var self = this;


        if (type === 'string') {
          data = {
            'text': data
          };
        } else {
          if (data.logglyCollectorDomain) {
            self.logglyCollectorDomain = data.logglyCollectorDomain;
            return;
          }

          if (data.sendConsoleErrors !== undefined) {
            setSendConsoleError(self, data.sendConsoleErrors);
          }

          if (data.tag) {
            setTag(self, data.tag);
          }

          if (data.useDomainProxy) {
            setDomainProxy(self, data.useDomainProxy);
          }

          if (data.logglyKey) {
            setKey(self, data.logglyKey);
            return;
          }

          if (data.session_id) {
            self.setSession(data.session_id);
            return;
          }
        }

        if (!self.key) {
          return;
        }

        self.track(data);


      },
      track: function (data) {
        // inject session id
        data.sessionId = this.session_id;

        try {
          //creating an asynchronous XMLHttpRequest
          var xmlHttp = new XMLHttpRequest();
          xmlHttp.open('POST', this.inputUrl, true); //true for asynchronous request
          xmlHttp.setRequestHeader('Content-Type', 'text/plain; charset=utf-8');
          xmlHttp.send(JSON.stringify(data));

        } catch (ex) {
          if (window && window.console && typeof window.console.log === 'function') {
            console.log("Failed to log to loggly because of this exception:\n" + ex);
            console.log("Failed log data:", data);
          }
        }
      },
      /**
       *  These cookie functions are not a global utilities.  It is for purpose of this tracker only
       */
      readCookie: function () {
        var cookie = document.cookie,
          i = cookie.indexOf(LOGGLY_SESSION_KEY);
        if (i < 0) {
          return false;
        } else {
          var end = cookie.indexOf(';', i + 1);
          end = end < 0 ? cookie.length : end;
          return cookie.slice(i + LOGGLY_SESSION_KEY_LENGTH, end);
        }
      },
      setCookie: function (value) {
        document.cookie = LOGGLY_SESSION_KEY + '=' + value;
      }
    };

    var existing = window._LTracker;

    var tracker = new LogglyTracker();

    if (existing && existing.length) {
      var i = 0,
        eLength = existing.length;
      for (i = 0; i < eLength; i++) {
        tracker.push(existing[i]);
      }
    }

     return tracker;
  };
}

从'@angular/core'导入{Injectable}；
@可注射（）
导出类日志{
私人拉客：任何；
构造函数（）{
this.LTracker=this.LTrack（窗口、文档）| |[]；
这个。拉卡。推({
“logglyKey”：“你的钥匙在这里”，
“sendConsoleErrors”：是，
'tag'：'loggly jslogger'
});
}
推（道具）{
这个.LTracker.push（道具）；
}
LTrack（窗口、文档）{
var LOGGLY_INPUT_PREFIX='http'+（'https:'==document.location.protocol？'s'：''）+'：/'，
LOGGLY_收集器_域='logs-01.LOGGLY.com'，
LOGGLY_SESSION_KEY='logglytrackingsession'，
LOGGLY_SESSION_KEY_LENGTH=LOGGLY_SESSION_KEY.LENGTH+1，
LOGGLY_PROXY_DOMAIN='LOGGLY'；
函数uuid（）{
//从这里提升->http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
返回“xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxx”。替换（/[xy]/g，函数（c）{
var r=Math.random（）*16 | 0，v=c='x'？r:（r&0x3 | 0x8）；
返回v.toString（16）；
});
}
函数LogglyTracker（）{
this.key=false；
this.sendConsoleErrors=false；
this.tag='jslogger'；
this.useDomainProxy=false；
}
功能设置键（跟踪器，键）{
tracker.key=key；
tracker.setSession（）；
setInputUrl（跟踪器）；
}
功能设置标签（跟踪器、标签）{
tracker.tag=标签；
}
函数setDomainProxy（跟踪器，useDomainProxy）{
tracker.useDomainProxy=useDomainProxy；
//刷新输入URL值
setInputUrl（跟踪器）；
}
函数setSendConsoleError（跟踪器、sendConsoleErrors）{
tracker.sendConsoleErrors=sendConsoleErrors；
如果（tracker.sendConsoleErrors===true）{
var_onerror=window.onerror；
//向Loggly发送控制台错误消息
window.onerror=函数（消息、url、行、列、错误）{
推({
类别：“BrowserJsException”，
例外情况：{
讯息:msg,，
url:url，
行否：行，
科诺：上校，
堆栈：err？err.stack:“不适用”，
}
});
if（_onerror&&typeof _onerror==='function'）{
_onerror.apply（窗口、参数）；
}
};
}
}
函数setInputUrl（跟踪器）{
如果（tracker.useDomainProxy==true）{
tracker.inputUrl=LOGGLY\u输入\u前缀
+window.location.host
+ '/'
+LOGGLY_代理_域
+“/inputs/”
+跟踪键
+“/tag/”
+tracker.tag；
}
否则{
tracker.inputUrl=LOGGLY\u输入\u前缀
+（tracker.logglyCollectorDomain | | LOGGLY_COLLECTOR_DOMAIN）
+“/inputs/”
+跟踪键
+“/tag/”
+tracker.tag；
}
}
LogglyTracker.prototype={
设置会话：功能（会话id）{
如果（会话id）{
this.session\u id=session\u id；
this.setCookie（this.session\u id）；
}否则如果（！this.session\u id）{
this.session_id=this.readCookie（）；
如果（！this.session\u id）{
this.session_id=uuid（）；
this.setCookie（this.session\u id）；
}
}
},
推送：功能（数据）{
变量类型=数据类型；
如果（！data | |！（type=='object'| | type=='string'））{
返回；
}
var self=这个；
如果（类型=='string'）{
数据={
“文本”：数据
};
}否则{
if（data.LoggCollectorDomain）{
self.logglyCollectorDomain=data.logglyCollectorDomain；
返回；
}
if（data.sendConsoleErrors！==未定义）{
setSendConsoleError（self，data.sendConsoleErrors）；
}
if（data.tag）{
setTag（self，data.tag）；
}
if（data.useDomainProxy）{
setDomainProxy（self，data.useDomainProxy）；
}
if（data.logglyKey）{
设置键（self，data.logglyKey）；
返回；
}
if（数据会话\u id）{
self.setSession（data.session_id）；
返回；
}
}
如果（！self.key）{
返回；
}
自我跟踪（数据）；
},
跟踪：功能（数据）{
//注入会话id
data.sessionId=this.session\u id；
试一试{
//创建异步XMLHttpRequest
var xmlHttp=new XMLHttpRequest（）；
xmlHttp.open（'POST'，this.input）