private void Render(LayoutElement element, ICanvas canvas)
{
try {
var innerBoundaries = element.Presentation.Render(canvas);
if (innerBoundaries == null)
{
return;
}
var innerCanvasPosition = innerBoundaries.GetBounds();
if (innerCanvasPosition.IsEmpty)
{
return;
}
var innerCanvas = new GDICanvas(innerCanvasPosition.Size);
innerCanvas.Boundaries = TransformBoundariesToTopLeft(innerBoundaries);
foreach (var child in element.Children)
{
Render(child, innerCanvas);
var picture = innerCanvas.Picture;
canvas.DrawImage(picture,
new RectangleF(innerCanvasPosition.Left, innerCanvasPosition.Top,
innerCanvasPosition.Width, innerCanvasPosition.Height),
new RectangleF(0, 0, picture.Width, picture.Height));
}
} catch (Exception ex) {
var failedImage = GetFailedRenderImage(canvas.Boundaries.GetBounds().Size);
canvas.DrawImage(failedImage,
new RectangleF(0, 0, failedImage.Width, failedImage.Height),
new RectangleF(0, 0, failedImage.Width, failedImage.Height));
LogPolicy.LogException(ex);
}
}
public override void Log(String message, LogPolicy logPolicy, Int32 eventId, short category)
{
String logLine = String.Format("{0}: {1:G}: {2},{3}: {4}.", logPolicy, DateTime.Now, eventId, category,
message);
Trace.WriteLine(logLine);
}
public virtual void Log(String message, LogPolicy logPolicy, Int32 eventId, short category)
{
if (_logPolicies.Contains(logPolicy))
{
LogToLoggers(message, logPolicy, eventId, category);
}
}
public void Logger_Constructor_ThrowsOnNullWriter()
{
var policy = new LogPolicy()
{
};
var logger = new Logger(policy);
}
private static void DemoLogger()
{
LogPolicy.Register(new DemoLogger());
LogPolicy.Log(LogDefinition.ApplicationLaunch, "Helper Demo");
LogPolicy.Log(HelperDemoLogDefintion.Foo);
LogPolicy.Log(HelperDemoLogDefintion.Bar);
LogPolicy.Log(LogDefinition.ApplicationExit, "Helper Demo");
}
public void ShowLogPolicy()
{
Console.WriteLine();
Console.WriteLine("Showing current log policy...");
LogPolicy policy = sequence.LogStore.Policy;
Console.WriteLine(" Minimum extent count: {0}", policy.MinimumExtentCount);
Console.WriteLine(" Maximum extent count: {0}", policy.MaximumExtentCount);
Console.WriteLine(" Growth rate: {0}", policy.GrowthRate);
Console.WriteLine(" Pinned tail threshold: {0}", policy.PinnedTailThreshold);
Console.WriteLine(" Auto shrink percent: {0}", policy.AutoShrinkPercentage);
Console.WriteLine(" Auto grow enabled: {0}", policy.AutoGrow);
Console.WriteLine(" New extent prefix: {0}", policy.NewExtentPrefix);
Console.WriteLine(" Next extent suffix: {0}", policy.NextExtentSuffix);
}
protected virtual void LogToLoggers(String message, LogPolicy logPolicy, Int32 eventId, short category)
{
foreach (ILogContext logger in _loggers)
{
//if log implements ILogAsync then invoke it on a separate thread
if (IsAsync)
{
AsyncMethodCaller caller = logger.Log;
caller.BeginInvoke(message, logPolicy, eventId, category, WriteCallbackMethod, null);
}
else
{
logger.Log(message, logPolicy, eventId, category);
}
}
}
public void LogCallContext_ContextProviderAddsFromCallContext()
{
var eventList = new List <LogEvent>();
var policy = new LogPolicy()
{
ContextProviders = new ILogEventContextProvider[] { new ContextProviders.LogCallContextLogEventContextProvider() },
LogWriter = new ListLogWriter(eventList, 10)
};
var logger = new Logger(policy);
using (var signal = new System.Threading.ManualResetEvent(false))
{
using (var prop = LogCallContext.PushProperty("Test Prop 1", Guid.NewGuid()))
{
using (var prop2 = LogCallContext.PushProperty("Test Prop 2", Guid.NewGuid()))
{
System.Threading.ThreadPool.QueueUserWorkItem((reserved) =>
{
logger.WriteEvent("Test event");
signal.Set();
});
signal.WaitOne();
Assert.AreEqual(eventList.Last().Properties.Count, 2);
Assert.AreEqual(eventList.Last().Properties.First().Key, "Test Prop 2");
Assert.AreEqual(eventList.Last().Properties.Last().Key, "Test Prop 1");
}
}
signal.Reset();
var contextWasEmptyOnOtherThread = false;
System.Threading.ThreadPool.QueueUserWorkItem((reserved) =>
{
contextWasEmptyOnOtherThread = !LogCallContext.CurrentProperties.Any();
signal.Set();
});
signal.WaitOne();
Assert.IsTrue(contextWasEmptyOnOtherThread);
}
}
public void ForwardingWriter_Write_WritesToInnerLogger()
{
var list = new List <LogEvent>();
var listWriter = new ListLogWriter(list, 10);
var policy = new LogPolicy()
{
LogWriter = listWriter
};
var innerLogger = new Logger(policy);
var writer = new ForwardingLogWriter(innerLogger);
var logEvent = new LogEvent()
{
EventName = "Test log event."
};
writer.Write(logEvent);
Assert.AreEqual(1, list.Count);
Assert.AreEqual("Test log event.", list[0].EventName);
}
public override void Log(String message, LogPolicy logPolicy, Int32 eventId, short category)
{
switch (logPolicy)
{
case LogPolicy.Critical:
case LogPolicy.Error:
_eventLog.WriteEntry(message, EventLogEntryType.Error, eventId, category);
break;
case LogPolicy.Warning:
_eventLog.WriteEntry(message, EventLogEntryType.Warning, eventId, category);
break;
case LogPolicy.Information:
_eventLog.WriteEntry(message, EventLogEntryType.Information, eventId, category);
break;
default:
_eventLog.WriteEntry(message, EventLogEntryType.Error, eventId, category);
break;
}
}
public override void Log(String message, LogPolicy logPolicy, Int32 eventId, short category)
{
String logLine = String.Format("{0}: {1:G}: {2},{3}: {4}.", logPolicy, DateTime.Now, eventId, category,
message);
const String sqlQuery =
"Insert Into Logger (Message, LogPolicy, EventId, Category, AddedDate) Values (@Message, @LogPolicy, @EventId, @Category, @AddedDate)";
_command.CommandText = sqlQuery;
_command.CommandType = CommandType.Text;
AddParameter("@Message", message);
AddParameter("@LogPolicy", logPolicy);
AddParameter("@EventId", eventId);
AddParameter("@Category", category);
AddParameter("@AddedDate", DateTime.Now);
try
{
if (_connection.State == ConnectionState.Closed)
{
_connection.Open();
}
_command.ExecuteNonQuery();
}
catch (Exception exception)
{
var debugLogger = new DebugDefaultLogContext();
debugLogger.Log(exception.Message);
var traceLogger = new TraceDefaultLogContext();
traceLogger.Log(exception.Message);
}
finally
{
_command.Parameters.Clear();
//_connection.Close();
}
Debug.WriteLine(logLine);
}
public override void Log(String message, LogPolicy logPolicy, Int32 eventId, short category)
{
_bodyTemplate = String.Format(_bodyTemplate, message);
//Emailer.Emailer.SendMail(_fromAddress, _toAddress, _subject, _bodyTemplate);
}
public void SetLogPolicy()
{
Console.WriteLine();
Console.WriteLine("Setting current log policy...");
// <Snippet2>
// SET LOG POLICY
LogPolicy policy = sequence.LogStore.Policy;
// Set AutoGrow policy. This enables the log to automatically grow
// when the existing extents are full. New extents are added until
// we reach the MaximumExtentCount extents.
// AutoGrow policy is supported only in Windows Vista and not available in R2.
//policy.AutoGrow = true;
// Set the Growth Rate in terms of extents. This policy specifies
// "how much" the log should grow.
policy.GrowthRate = new PolicyUnit(2, PolicyUnitType.Extents);
// Set the AutoShrink policy. This enables the log to automatically
// shrink if the available free space exceeds the shrink percentage.
// AutoGrow/shrink policy is supported only in Windows Vista and not available in R2.
//policy.AutoShrinkPercentage = new PolicyUnit(30, PolicyUnitType.Percentage);
// Set the PinnedTailThreshold policy.
// A tail pinned event is triggered when there is no
// log space available and log space may be freed by advancing the base.
// The user must handle the tail pinned event by advancing the base of the log.
// If the user is not able to move the base of the log, the user should report with exception in
// the tail pinned handler.
// PinnedTailThreashold policy dictates the amount of space that the TailPinned event requests
// for advancing the base of the log. The amount of space can be in percentage or in terms of bytes
// which is rounded off to the nearest containers in CLFS. The default is 35 percent.
policy.PinnedTailThreshold = new PolicyUnit(10, PolicyUnitType.Percentage);
// Set the maximum extents the log can have.
policy.MaximumExtentCount = 6;
// Set the minimum extents the log can have.
policy.MinimumExtentCount = 2;
// Set the prefix for new containers that are added.
// when AutoGrow is enabled.
//policy.NewExtentPrefix = "MyLogPrefix";
// Set the suffix number for new containers that are added.
// when AutoGrow is enabled.
policy.NextExtentSuffix = 3;
// Commit the log policy.
policy.Commit();
// Refresh updates the IO.Log policy properties with current log policy
// set in the log.
policy.Refresh();
// LOG POLICY END
//
// </Snippet2>
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Setting up IO.Log provided capabilities...
//
// <Snippet3>
// SET RETRY APPEND
// IO.Log provides a mechanism similar to AutoGrow.
// If the existing log is full and an append fails, setting RetryAppend
// invokes the CLFS policy engine to add new extents and re-tries
// record appends. If MaximumExtent count has been reached,
// a SequenceFullException is thrown.
//
sequence.RetryAppend = true;
// RETRY APPEND END
// </Snippet3>
// <Snippet4>
// REGISTER FOR TAILPINNED EVENT NOTIFICATIONS
// Register for TailPinned Event by passing in an event handler.
// An event is raised when the log full condition is reached.
// The user should either advance the base sequence number to the
// nearest valid sequence number recommended in the tail pinned event or
// report a failure that it is not able to advance the base sequence
// number.
//
sequence.TailPinned += new EventHandler <TailPinnedEventArgs>(HandleTailPinned);
// </Snippet4>
Console.WriteLine("Done...");
}
public virtual void Log(String message, LogPolicy logPolicy)
{
LogToLoggers(message, logPolicy, 1, 1);
}
static void Main(string[] args)
{
//int testIterations = 100;
//TimeSpan maxTime = TimeSpan.FromMilliseconds(10); // This is generous, to allow for variations caused by things outside the logging system (GC/CLR/OS etc)
//var list = new List<LogEvent>(1);
//var policy = GetSimpleListPolicy(list);
//var logger = new Logger(policy);
//var sw = new System.Diagnostics.Stopwatch();
//sw.Start();
//for (int cnt = 0; cnt < testIterations; cnt++)
//{
// logger.WriteEvent($"Log this {cnt.ToString()}!");
// //logger.WriteEvent($"Log this!", LogEventSeverity.Information, LogEventType.ApplicationEvent, null, null);
//}
//sw.Stop();
var policy = new LogPolicy()
{
LogWriter = new ScribeSharp.Writers.AggregateLogWriter(
new ILogWriter[]
{
new ScribeSharp.Writers.ConsoleLogWriter(null),
new ScribeSharp.Writers.WindowsEventLogWriter("TestLog", "Test Source", ".", true, System.Diagnostics.OverflowAction.OverwriteAsNeeded, 30,
new ScribeSharp.Formatters.XmlLogEventFormatter())
}
),
//PropertyRenderers = new Dictionary<Type, IPropertyRenderer>() { { typeof(TestProperty), new PropertyRenderers.XmlPropertyRenderer(typeof(TestProperty)) } }
};
var logger = new Logger(policy);
logger.WriteEventWithSource("Started");
logger.WriteEventWithSource("Test", LogEventSeverity.Information);
logger.WriteEventWithSource("Error", eventSeverity: LogEventSeverity.Error);
try
{
throw new System.IO.FileNotFoundException("File c:\\temp\\test.txt", "c:\\temp\\test.txt");
}
catch (Exception ex)
{
logger.WriteEvent(ex);
}
var props = new KeyValuePair <string, object>[] { new KeyValuePair <string, object>("Test1", "Test2"), new KeyValuePair <string, object>("Test2", new TestProperty()) };
logger.WriteEventWithSource("Test", properties: props);
var childLogger = logger.CreateChildLogger("childlogger");
childLogger.WriteEventWithSource("Child logger test.");
logger.WriteEventWithSource("Test", LogEventSeverity.Diagnostic, LogEventType.ScheduledEvent);
logger.WriteEventWithSource("Test1", LogEventSeverity.Diagnostic);
logger.WriteEvent("Test1", LogEventSeverity.Diagnostic, LogEventType.ScheduledEvent, new KeyValuePair <string, object>("Test2", "Test2"));
logger.WriteEventWithSource("Stopped");
Console.ReadLine();
}
private ConsoleLogger(DebugSettings settings)
{
m_policy = new FilePolicy(settings);
}
