Skip to content

Commit

Permalink
Remove supporting obsolete types
Browse files Browse the repository at this point in the history
  • Loading branch information
Davoud Eshtehari authored and Davoud Eshtehari committed Sep 2, 2020
1 parent 0df6a55 commit 2ef8648
Showing 1 changed file with 29 additions and 172 deletions.
201 changes: 29 additions & 172 deletions ...t.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlClientEventSource.NetCoreApp2.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,266 +2,123 @@
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System.Diagnostics.Tracing;
using System.Threading;

namespace Microsoft.Data.SqlClient
{
/// <summary>
/// supported frameworks: .Net core 2.1 and .Net standard 2.0
/// not implemented cause of low performance for .Net core 2.1 and .Net standard 2.0
/// </summary>
internal partial class SqlClientEventSource : SqlClientEventSourceBase
{
private EventCounter _activeHardConnections;
private EventCounter _hardConnectsPerSecond;
private EventCounter _hardDisconnectsPerSecond;

private EventCounter _activeSoftConnections;
private EventCounter _softConnects;
private EventCounter _softDisconnects;

private EventCounter _numberOfNonPooledConnections;
private EventCounter _numberOfPooledConnections;

private EventCounter _numberOfActiveConnectionPoolGroups;
private EventCounter _numberOfInactiveConnectionPoolGroups;

private EventCounter _numberOfActiveConnectionPools;
private EventCounter _numberOfInactiveConnectionPools;

private EventCounter _numberOfActiveConnections;
private EventCounter _numberOfFreeConnections;
private EventCounter _numberOfStasisConnections;
private EventCounter _numberOfReclaimedConnections;

private long _activeHardConnectionsCounter = 0;
private long _hardConnectsCounter = 0;
private long _hardDisconnectsCounter = 0;

private long _activeSoftConnectionsCounter = 0;
private long _softConnectsCounter = 0;
private long _softDisconnectsCounter = 0;

private long _nonPooledConnectionsCounter = 0;
private long _pooledConnectionsCounter = 0;

private long _activeConnectionPoolGroupsCounter = 0;
private long _inactiveConnectionPoolGroupsCounter = 0;

private long _activeConnectionPoolsCounter = 0;
private long _inactiveConnectionPoolsCounter = 0;

private long _activeConnectionsCounter = 0;
private long _freeConnectionsCounter = 0;
private long _stasisConnectionsCounter = 0;
private long _reclaimedConnectionsCounter = 0;

protected override void EventCommandMethodCall(EventCommandEventArgs command)
{
if (command.Command != EventCommand.Enable)
{
return;
}

_activeHardConnections = _activeHardConnections ?? new EventCounter("active-hard-connections", this);
_hardConnectsPerSecond = _hardConnectsPerSecond ?? new EventCounter("hard-connects", this);
_hardDisconnectsPerSecond = _hardDisconnectsPerSecond ?? new EventCounter("hard-disconnects", this);

_activeSoftConnections = _activeSoftConnections ?? new EventCounter("active-soft-connects", this);
_softConnects = _softConnects ?? new EventCounter("soft-connects", this);
_softDisconnects = _softDisconnects ?? new EventCounter("soft-disconnects", this);

_numberOfNonPooledConnections = _numberOfNonPooledConnections ?? new EventCounter("number-of-non-pooled-connections", this);
_numberOfPooledConnections = _numberOfPooledConnections ?? new EventCounter("number-of-pooled-connections", this);
_numberOfActiveConnectionPoolGroups = _numberOfActiveConnectionPoolGroups ?? new EventCounter("number-of-active-connection-pool-groups", this);
_numberOfInactiveConnectionPoolGroups = _numberOfInactiveConnectionPoolGroups ?? new EventCounter("number-of-inactive-connection-pool-groups", this);
_numberOfActiveConnectionPools = _numberOfActiveConnectionPools ?? new EventCounter("number-of-active-connection-pools", this);
_numberOfInactiveConnectionPools = _numberOfInactiveConnectionPools ?? new EventCounter("number-of-inactive-connection-pools", this);
_numberOfActiveConnections = _numberOfActiveConnections ?? new EventCounter("number-of-active-connections", this);
_numberOfFreeConnections = _numberOfFreeConnections ?? new EventCounter("number-of-free-connections", this);
_numberOfStasisConnections = _numberOfStasisConnections ?? new EventCounter("number-of-stasis-connections", this);
_numberOfReclaimedConnections = _numberOfReclaimedConnections ?? new EventCounter("number-of-reclaimed-connections", this);
}

/// <summary>
/// The number of actual connections that are being made to servers
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
[NonEvent]
internal void HardConnectRequest()
{
if (IsEnabled())
{
var counter = Interlocked.Increment(ref _activeHardConnectionsCounter);
_activeHardConnections.WriteMetric(counter);

counter = Interlocked.Increment(ref _hardConnectsCounter);
_hardConnectsPerSecond.WriteMetric(counter);
}
//no-op
}

/// <summary>
/// The number of actual disconnects that are being made to servers
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
[NonEvent]
internal void HardDisconnectRequest()
{
if (IsEnabled())
{
var counter = Interlocked.Decrement(ref _activeHardConnectionsCounter);
_activeHardConnections.WriteMetric(counter);

counter = Interlocked.Increment(ref _hardDisconnectsCounter);
_hardDisconnectsPerSecond.WriteMetric(counter);
}
//no-op
}

/// <summary>
/// The number of connections we get from the pool
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
[NonEvent]
internal void SoftConnectRequest()
{
if (IsEnabled())
{
var counter = Interlocked.Increment(ref _activeSoftConnectionsCounter);
_activeSoftConnections.WriteMetric(counter);

counter = Interlocked.Increment(ref _softConnectsCounter);
_softConnects.WriteMetric(counter);
}
//no-op
}

/// <summary>
/// The number of connections we return to the pool
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
[NonEvent]
internal void SoftDisconnectRequest()
{
if (IsEnabled())
{
var counter = Interlocked.Decrement(ref _activeSoftConnectionsCounter);
_activeSoftConnections.WriteMetric(counter);

counter = Interlocked.Increment(ref _softDisconnectsCounter);
_softDisconnects.WriteMetric(counter);
}
//no-op
}

/// <summary>
/// The number of connections that are not using connection pooling
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void NonPooledConnectionRequest(bool increment = true)
{
Request(ref _numberOfNonPooledConnections, ref _nonPooledConnectionsCounter, increment);
//no-op
}

/// <summary>
/// The number of connections that are managed by the connection pooler
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void PooledConnectionRequest(bool increment = true)
{
Request(ref _numberOfPooledConnections, ref _pooledConnectionsCounter, increment);
//no-op
}

/// <summary>
/// The number of unique connection strings
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void ActiveConnectionPoolGroupRequest(bool increment = true)
{
Request(ref _numberOfActiveConnectionPoolGroups, ref _activeConnectionPoolGroupsCounter, increment);
//no-op
}

/// <summary>
/// The number of unique connection strings waiting for pruning
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void InactiveConnectionPoolGroupRequest(bool increment = true)
{
Request(ref _numberOfInactiveConnectionPoolGroups, ref _inactiveConnectionPoolGroupsCounter, increment);
//no-op
}

/// <summary>
/// The number of connection pools
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void ActiveConnectionPoolRequest(bool increment = true)
{
Request(ref _numberOfActiveConnectionPools, ref _activeConnectionPoolsCounter, increment);
//no-op
}

/// <summary>
/// The number of connection pools
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void InactiveConnectionPoolRequest(bool increment = true)
{
Request(ref _numberOfInactiveConnectionPools, ref _inactiveConnectionPoolsCounter, increment);
//no-op
}

/// <summary>
/// The number of connections currently in-use
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void ActiveConnectionRequest(bool increment = true)
{
Request(ref _numberOfActiveConnections, ref _activeConnectionsCounter, increment);
//no-op
}

/// <summary>
/// The number of connections currently available for use
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void FreeConnectionRequest(bool increment = true)
{
Request(ref _numberOfFreeConnections, ref _freeConnectionsCounter, increment);
//no-op
}

/// <summary>
/// The number of connections currently waiting to be made ready for use
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
/// <param name="increment"></param>
[NonEvent]
internal void StasisConnectionRequest(bool increment = true)
{
Request(ref _numberOfStasisConnections, ref _stasisConnectionsCounter, increment);
//no-op
}

/// <summary>
/// The number of connections we reclaim from GC'd external connections
/// not implemented for .Net core 2.1, .Net standard 2.0 and lower
/// </summary>
[NonEvent]
internal void ReclaimedConnectionRequest()
{
Request(ref _numberOfReclaimedConnections, ref _reclaimedConnectionsCounter, true);
}

[NonEvent]
private void Request(ref EventCounter eventCounter, ref long counter, bool increment)
{
if (IsEnabled())
{
long innerCounter;
if (increment)
{
innerCounter = Interlocked.Increment(ref counter);
}
else
{
innerCounter = Interlocked.Decrement(ref counter);
}
eventCounter.WriteMetric(innerCounter);
}
//no-op
}
}
}

0 comments on commit 2ef8648

Please sign in to comment.