public void Constructor_ValidHttpsUri_SentryUriHasHttpsScheme() { var dsn = new Dsn(TestHelper.DsnUri); Assert.That(dsn.SentryUri, Is.Not.Null); Assert.That(dsn.SentryUri.Scheme, Is.EqualTo("https")); }
public static void RavenStorageTestsInit(TestContext context) { Dsn dsn = new Dsn(RavenConfig.DSN); RavenClient.InitializeAsync(dsn); _storageClient = new RavenStorageClient(); }
public void Constructor_ValidHttpsUri_UriIsEqualToDsn() { var dsn = new Dsn(TestHelper.DsnUri); Assert.That(dsn.Uri, Is.Not.Null); Assert.That(dsn.Uri.ToString(), Is.EqualTo(TestHelper.DsnUri)); }
public void Constructor_ValidHttpUri_SentryUriHasHttpScheme() { const string dsnUri = "http://*****:*****@app.getsentry.com/3739"; var dsn = new Dsn(dsnUri); Assert.That(dsn.SentryUri, Is.Not.Null); Assert.That(dsn.SentryUri.Scheme, Is.EqualTo("http")); }
public void CreateAuthenticationHeader_ReturnsCorrectAuthenticationHeader() { const string expected = @"^Sentry sentry_version=4, sentry_client=SharpRaven/[\d\.]+, sentry_timestamp=\d+, sentry_key=7d6466e66155431495bdb4036ba9a04b, sentry_secret=4c1cfeab7ebd4c1cb9e18008173a3630$"; var dsn = new Dsn( "https://*****:*****@app.getsentry.com/3739"); var authenticationHeader = PacketBuilder.CreateAuthenticationHeader(dsn); Assert.That(authenticationHeader, Is.StringMatching(expected)); }
/// <summary> /// Creates the authentication header base on the provided <see cref="Dsn"/>. /// </summary> /// <param name="dsn">The DSN.</param> /// <returns> /// The authentication header. /// </returns> public static string CreateAuthenticationHeader(Dsn dsn) { return String.Format("Sentry sentry_version={0}" + ", sentry_client={1}" + ", sentry_timestamp={2}" + ", sentry_key={3}" + ", sentry_secret={4}", SentryVersion, UserAgent, (long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds, dsn.PublicKey, dsn.PrivateKey); }
public void Test_Create_Valid_Dsn() { try { Dsn dsn = new Dsn("http://*****:*****@example.com/projectid"); Assert.AreEqual("public", dsn.PublicKey); Assert.AreEqual("private", dsn.PrivateKey); Assert.AreEqual("projectid", dsn.ProjectID); } catch (ArgumentException ex) { Assert.Fail(ex.Message); } }
public OptionalHub(SentryOptions options) { options.SetupLogging(); if (options.Dsn == null) { if (!Dsn.TryParse(DsnLocator.FindDsnStringOrDisable(), out var dsn)) { options.DiagnosticLogger?.LogWarning("Init was called but no DSN was provided nor located. Sentry SDK will be disabled."); _hub = DisabledHub.Instance; return; } options.Dsn = dsn; } _hub = new Hub(options); }
public async Task CapturesRequestData(string eventId, string method, string url) { var uri = new Uri(url, UriKind.Absolute); var reqMock = new Mock <HttpRequest>(); reqMock.SetupGet(r => r.Method).Returns(method); reqMock.SetupGet(r => r.Scheme).Returns(uri.Scheme); reqMock.SetupGet(r => r.Host).Returns(new HostString(uri.Host)); reqMock.SetupGet(r => r.Path).Returns(uri.AbsolutePath); reqMock.SetupGet(r => r.QueryString) .Returns(QueryString.FromUriComponent(uri.Query)); reqMock.SetupGet(r => r.Query) .Returns(new QueryCollection(QueryHelpers.ParseQuery(uri.Query))); var httpMock = new Mock <HttpContext>(); httpMock.Setup(m => m.Items) .Returns(new Dictionary <object, object>()); httpMock.SetupGet(c => c.Request) .Returns(reqMock.Object); var clientMock = new Mock <SentryClient>( Dsn.Create(ExceptionReportingOptions.Dsn)); clientMock.Setup(c => c.SendEventAsync(It.Is <SentryEventData>(r => r.Request.Url == url.Split('?', StringSplitOptions.None)[0] && r.Request.Method == method && r.Request.QueryString == uri.Query))) .ReturnsAsync(new SentryResponse { EventId = eventId }) .Verifiable(); var middleware = CreateMiddleware(Next_Throw, clientMock.Object); await Assert.ThrowsAsync <InvalidOperationException>( () => middleware.Invoke(httpMock.Object)); clientMock.Verify(); }
public string Send(JsonPacket packet, Dsn dsn) { try { var ts = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds; var webRequest = (HttpWebRequest)WebRequest.Create(dsn.SentryUri); webRequest.Method = "POST"; webRequest.Accept = "application/json"; webRequest.Headers["X-Sentry-Auth"] = $"Sentry sentry_version={7},sentry_client=steepshot/1, sentry_timestamp={ts}, sentry_key={dsn.PublicKey}, sentry_secret={dsn.PrivateKey}"; webRequest.ContentType = "application/json; charset=utf-8"; using (var s = webRequest.GetRequestStreamAsync().Result) { var txt = packet.ToString(); using (var sw = new StreamWriter(s)) { sw.Write(txt); } } using (var wr = webRequest.GetResponseAsync().Result) { using (var responseStream = wr.GetResponseStream()) { if (responseStream == null) { return(null); } using (var sr = new StreamReader(responseStream)) { var content = sr.ReadToEnd(); var response = JsonConvert.DeserializeObject <JObject>(content); return(response.Value <string>("id")); } } } } catch (Exception exception) { return(exception.Message); } }
public void CreateRequest_SentryUrl_FromOptions() { // Arrange var httpTransport = new HttpTransport( new SentryOptions { Dsn = DsnSamples.ValidDsnWithSecret }, new HttpClient()); var envelope = Envelope.FromEvent(new SentryEvent()); var uri = Dsn.Parse(DsnSamples.ValidDsnWithSecret).GetEnvelopeEndpointUri(); // Act var request = httpTransport.CreateRequest(envelope); // Assert request.RequestUri.Should().Be(uri); }
internal HttpRequestMessage CreateRequest(Envelope envelope) { if (string.IsNullOrWhiteSpace(_options.Dsn)) { throw new InvalidOperationException("The DSN is expected to be set at this point."); } var dsn = Dsn.Parse(_options.Dsn); var request = new HttpRequestMessage { RequestUri = dsn.GetEnvelopeEndpointUri(), Method = HttpMethod.Post, Content = new SerializableHttpContent(envelope) }; _addAuth(request.Headers); return(request); }
/// <summary> /// Initializes a new instance of the <see cref="HttpRequester"/> class. /// </summary> /// <param name="data">The request data.</param> /// <param name="dsn">The DSN used in this request</param> /// <param name="timeout">The request timeout.</param> /// <param name="useCompression">Whether to use compression or not.</param> public HttpRequester(RequestData data, Dsn dsn, TimeSpan timeout, bool useCompression) { this.data = data ?? throw new ArgumentNullException(nameof(data)); this.timeout = timeout == default ? TimeSpan.FromSeconds(5) : timeout; this.useCompression = useCompression; this.webRequest = CreateWebRequest(dsn.SentryUri, dsn); if (useCompression) { this.webRequest.Headers.Add(HttpRequestHeader.ContentEncoding, "gzip"); this.webRequest.AutomaticDecompression = DecompressionMethods.Deflate; this.webRequest.ContentType = "application/octet-stream"; } else { this.webRequest.ContentType = "application/json; charset=utf-8"; } }
public SentryErrorReporting(string sentryURL, string environment, string version, string userGUID, Platform platform, string platformVersion, bool scrubUserName = false, Dictionary <string, string> extraTags = null) { _sentryDsn = new Dsn(sentryURL); _userGUID = userGUID; InitialiseSentryClient(); _sentryClient.Environment = environment; _sentryClient.Release = version; _sentryClient.Tags["OS"] = $"{platform} {platformVersion}"; if (extraTags != null) { AddTags(extraTags); } if (scrubUserName) { _sentryClient.LogScrubber = new SentryUserScrubber(); } }
public void SentryDsn_ContainsExpectedValues(string dsnValue) { var dsn = Dsn.Create(dsnValue); var auth = SentryAuth.Issue(dsn, IssuedAt); var values = SentryAuthHeader.GetValues(auth); Assert.Contains($"Sentry sentry_version={auth.SentryVersion}", values); Assert.Contains($"sentry_timestamp={auth.Timestamp}", values); Assert.Contains($"sentry_key={auth.PublicKey}", values); if (dsn.GetSecretKey() != null) { Assert.Contains($"sentry_secret={auth.SecretKey}", values); } else { Assert.DoesNotContain("sentry_secret", values); } Assert.Contains($"sentry_client={auth.ClientVersion}", values); }
private void DbConnectForm_FormClosing(object sender, FormClosingEventArgs e) { if (this.DialogResult == DialogResult.OK) { bool rinf; rinf = this.DbOpen();// OKならINIファイルを更新して抜ける if (rinf != true) { //NGだからダイアログを閉じない e.Cancel = true; } else { //OKだからINIファイル更新 aIniFile.WriteString("DataBase", "DSN", Dsn.Trim()); aIniFile.WriteString("DataBase", "UID", Uid.Trim()); aIniFile.WriteString("DataBase", "PWD", Pwd.Trim()); } } }
internal Hub(ISentryClient client, SentryOptions options) { _ownedClient = client; _options = options; if (options.Dsn is null) { var dsn = DsnLocator.FindDsnStringOrDisable(); if (Dsn.TryParse(dsn) is null) { const string msg = "Attempt to instantiate a Hub without a DSN."; options.DiagnosticLogger?.LogFatal(msg); throw new InvalidOperationException(msg); } options.Dsn = dsn; } options.DiagnosticLogger?.LogDebug("Initializing Hub for Dsn: '{0}'.", options.Dsn); ScopeManager = new SentryScopeManager(options, _ownedClient); _integrations = options.Integrations; if (_integrations?.Length > 0) { foreach (var integration in _integrations) { options.DiagnosticLogger?.LogDebug("Registering integration: '{0}'.", integration.GetType().Name); integration.Register(this, options); } } // Push the first scope so the async local starts from here _rootScope = PushScope(); }
internal HttpRequestMessage CreateRequest(Envelope envelope) { if (string.IsNullOrWhiteSpace(_options.Dsn)) { throw new InvalidOperationException("The DSN is expected to be set at this point."); } var dsn = Dsn.Parse(_options.Dsn); var authHeader = $"Sentry sentry_version={_options.SentryVersion}," + $"sentry_client={_options.ClientVersion}," + $"sentry_key={dsn.PublicKey}," + (dsn.SecretKey is { } secretKey ? $"sentry_secret={secretKey}," : null) + $"sentry_timestamp={_clock.GetUtcNow().ToUnixTimeSeconds()}"; return(new HttpRequestMessage { RequestUri = dsn.GetEnvelopeEndpointUri(), Method = HttpMethod.Post, Headers = { { "X-Sentry-Auth", authHeader } }, Content = new EnvelopeHttpContent(envelope) }); }
public void Start() { #if UNITY_EDITOR UnityEngine.Debug.LogWarning("This script is running in editormode. It will not send any message to sentry."); return; #endif if (Dsn == string.Empty) { // Empty string = disabled SDK UnityDebug.LogWarning("No DSN defined. The Sentry SDK will be disabled."); return; } if (_instance == null) { try { _dsn = new Dsn(Dsn); } catch (Exception e) { UnityDebug.LogError(string.Format("Error parsing DSN: {0}", e.Message)); return; } _breadcrumbs = new Breadcrumb[Breadcrumb.MaxBreadcrumbs]; DontDestroyOnLoad(this); _instance = this; _initialized = true; } else { Destroy(this); } }
public async Task SendException_ReturnsEventId() { var client = Sentry.CreateClient(Dsn.Create(GetProductionDsn())); var value = 0; try { var x = 10 / value; } catch (Exception ex) { var response = await client.CaptureAsync(e => e .SetException(ex) .SetErrorLevel(ErrorLevel.Warning) .AddExtraData("test", new { IsTest = true }) .AddTag("test_tag", "yes")); Assert.NotNull(response.EventId); } }
public void IsDisabled_InvalidDsn_False() => Assert.False(Dsn.IsDisabled(DsnSamples.InvalidDsn));
public void IsDisabled_ValidDsn_False() => Assert.False(Dsn.IsDisabled(DsnSamples.ValidDsnWithSecret));
public void TryParse_NullDsn_ThrowsArgumentNull() { Assert.False(Dsn.TryParse(null, out var dsn)); Assert.Null(dsn); }
public void TryParse_NullDsn_ThrowsArgumentNull() { Assert.Null(Dsn.TryParse(null)); }
private static Dsn GetDsn(SentryOptions options) => !string.IsNullOrEmpty(options.Dsn) ? Dsn.Create(options.Dsn) : null;
public void IsDisabled_EmptyStringDsn_True() => Assert.True(Dsn.IsDisabled(string.Empty));
public void TryParse_SampleInvalidDsn_Fails() { Assert.False(Dsn.TryParse(DsnSamples.InvalidDsn, out var dsn)); Assert.Null(dsn); }
public void TryParse_SampleValidDsnWithSecret_Succeeds() { Assert.True(Dsn.TryParse(DsnSamples.ValidDsnWithSecret, out var dsn)); Assert.NotNull(dsn); }
public void Ctor_DisableSdk_ThrowsUriFormatException() { var ex = Assert.Throws <UriFormatException>(() => Dsn.Parse(Constants.DisableSdkDsnValue)); Assert.Equal("Invalid URI: The URI is empty.", ex.Message); }
protected override string Send(JsonPacket packet, Dsn dsn) { return packet.Project; }
public void ToString_ReturnsStringEqualToDsn() { var dsn = new Dsn(TestHelper.DsnUri); Assert.That(dsn.ToString(), Is.EqualTo(TestHelper.DsnUri)); }
public void IsDisabled_NullDsn_False() => Assert.False(Dsn.IsDisabled(null));
public TestableRavenClient(Dsn dsn, IJsonPacketFactory jsonPacketFactory) : base(dsn, jsonPacketFactory) { // This constructor must exist so Nancy can inject the Dsn and NancyContextJsonPacketFactory // that is registered in SentryRegistrations. @asbjornu this.dsn = dsn; }
public void IsDisabled_DisabledDsn_True() => Assert.True(Dsn.IsDisabled(Constants.DisableSdkDsnValue));
public void TryParse_DisabledSdk_Fails() { Assert.False(Dsn.TryParse(Constants.DisableSdkDsnValue, out var dsn)); Assert.Null(dsn); }
public void Ctor_NotUri_ThrowsUriFormatException() { var ex = Assert.Throws <UriFormatException>(() => Dsn.Parse("Not a URI")); Assert.Equal("Invalid URI: The format of the URI could not be determined.", ex.Message); }
public void Ctor_SampleValidDsnWithSecret_CorrectlyConstructs() { var dsn = new Dsn(DsnSamples.ValidDsnWithSecret); Assert.Equal(DsnSamples.ValidDsnWithSecret, dsn.ToString()); }
public static void RavenClientTestsInit(TestContext context) { Dsn dsn = new Dsn(RavenConfig.DSN); RavenClient.InitializeAsync(dsn); }
public void TryParse_EmptyStringDsn_ThrowsUriFormatException() { Assert.False(Dsn.TryParse(string.Empty, out var dsn)); Assert.Null(dsn); }
public void TryParse_NotUri_Fails() { Assert.False(Dsn.TryParse("Not a URI", out var dsn)); Assert.Null(dsn); }
public TestableSentryClient(Dsn dsn, Func <SentryEventData, SentryResponse> onSend) : base(dsn) => _onSend = onSend;