private void DetermineDateTimePart(string line)
{
foreach (var parser in _subParsers)
{
for (var firstIndex = 0; firstIndex < line.Length; ++firstIndex)
{
for (var lastIndex = firstIndex + parser.MinimumLength; lastIndex <= line.Length; ++lastIndex)
{
var dateTimeString = line.Substring(firstIndex, lastIndex - firstIndex);
try
{
DateTime unused;
if (parser.TryParse(dateTimeString, out unused))
{
var length = lastIndex - firstIndex;
DateTimeColumn = firstIndex;
DateTimeLength = length;
_determinedParser = parser;
return;
}
}
catch (Exception e)
{
++_numExceptions;
Log.ErrorFormat("Caught unexpected exception: {0}", e);
}
}
}
}
}
public void Constructor_NullParser_Throws()
{
ITimestampParser nullParser = null;
Assert.Throws <ArgumentNullException>(
() => new SubtitleTimestampsParser(nullParser));
}
/// <summary>
/// Initializes this parser.
/// </summary>
/// <param name="parser"></param>
public NoThrowTimestampParser(ITimestampParser parser)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
_parser = parser;
}
public SubtitleTimestampsParser(ITimestampParser timestampParser)
{
if (timestampParser == null)
{
throw new ArgumentNullException(nameof(timestampParser));
}
this.timestampParser = timestampParser;
}
internal InfluxRowContent(InfluxClient client, bool isBasedOnInterface, IEnumerable dataPoints, Func <TInfluxRow, string> getMeasurementName, InfluxWriteOptions options)
{
_isBasedOnInterface = isBasedOnInterface;
_dataPoints = dataPoints;
_getMeasurementName = getMeasurementName;
_options = options;
_timestampParser = client.TimestampParserRegistry.FindTimestampParserOrNull <TTimestamp>();
Headers.ContentType = TextMediaType;
}
/// <summary>
/// Initializes this text log file.
/// </summary>
/// <param name="scheduler"></param>
/// <param name="fileName"></param>
/// <param name="timestampParser">An optional timestamp parser that is used to find timestamps in log messages. If none is specified, then <see cref="TimestampParser"/> is used</param>
/// <param name="translator">An optional translator that is used to translate each log line in memory. If none is specified, then log lines are displayed as they are in the file on disk</param>
/// <param name="encoding">The encoding to use to interpet the file, if none is specified, then <see cref="Encoding.UTF8"/> is used</param>
public TextLogFile(ITaskScheduler scheduler,
string fileName,
ITimestampParser timestampParser = null,
ILogLineTranslator translator = null,
Encoding encoding = null)
: base(scheduler)
{
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
_fileName = fileName;
_fullFilename = fileName;
if (!Path.IsPathRooted(_fullFilename))
{
_fullFilename = Path.Combine(Directory.GetCurrentDirectory(), fileName);
}
if (translator != null)
{
_translator = new NoThrowLogLineTranslator(translator);
}
_entries = new List <LogLine>();
_properties = new LogFilePropertyList(LogFileProperties.Minimum);
_properties.SetValue(LogFileProperties.Name, _fileName);
_syncRoot = new object();
_encoding = encoding ?? Encoding.UTF8;
Log.DebugFormat("Log File '{0}' is interpreted using {1}", _fileName, _encoding.EncodingName);
if (timestampParser != null)
{
_timestampParser = new NoThrowTimestampParser(timestampParser);
}
else
{
_timestampParser = new TimestampParser();
}
StartTask();
}
private void DetermineDateTimePart(string line)
{
if (SkipLine(line))
{
return;
}
int lineLength = line.Length;
if (line.Length > MaxLineLength)
{
Log.WarnFormat("Line has a length ({1}) greater than {0} characters. A timestamp will only be looked for in the first {0} characters!", MaxLineLength, line.Length);
lineLength = MaxLineLength;
}
foreach (var parser in _subParsers)
{
for (var firstIndex = 0; firstIndex < lineLength; ++firstIndex)
{
for (var lastIndex = firstIndex + parser.MinimumLength; lastIndex <= lineLength; ++lastIndex)
{
var dateTimeString = line.Substring(firstIndex, lastIndex - firstIndex);
try
{
DateTime unused;
if (parser.TryParse(dateTimeString, out unused))
{
var length = lastIndex - firstIndex;
DateTimeColumn = firstIndex;
DateTimeLength = length;
_determinedParser = parser;
return;
}
}
catch (Exception e)
{
++_numExceptions;
Log.ErrorFormat("Caught unexpected exception: {0}", e);
}
}
}
}
}
private static async Task AddValuesToInfluxSeriesByInterfaceAsync <TInfluxRow, TTimestamp>(
InfluxSeries <TInfluxRow> influxSerie,
SeriesResult series,
InfluxClient client,
string db,
bool allowMetadataQuerying,
InfluxRowTypeInfo <TInfluxRow> propertyMap,
InfluxQueryOptions options,
ITimestampParser <TTimestamp> timestampParser)
where TInfluxRow : IInfluxRow <TTimestamp>, new()
{
// Values will be null, if there are no entries in the result set
if (series.Values != null)
{
var precision = options.Precision;
var name = series.Name;
var columns = series.Columns;
var setters = new Action <TInfluxRow, string, object> [columns.Count];
var dataPoints = new List <TInfluxRow>();
// Get metadata information about the measurement we are querying, as we dont know
// which columns are tags/fields otherwise
DatabaseMeasurementInfo meta = null;
if (allowMetadataQuerying)
{
meta = await client.GetMetaInformationAsync(db, name, options.MetadataExpiration).ConfigureAwait(false);
}
for (int i = 0; i < columns.Count; i++)
{
var columnName = columns[i];
if (!allowMetadataQuerying)
{
setters[i] = (row, fieldName, value) => row.SetField(fieldName, value);
}
else if (columnName == InfluxConstants.TimeColumn)
{
setters[i] = (row, timeName, value) => row.SetTimestamp(timestampParser.ToTimestamp(options.Precision, value));
}
else if (meta.Tags.Contains(columnName))
{
setters[i] = (row, tagName, value) => row.SetTag(tagName, (string)value);
}
else
{
setters[i] = (row, fieldName, value) => row.SetField(fieldName, value);
}
}
// constructs the IInfluxRows using the IInfluxRow interface
foreach (var values in series.Values)
{
var dataPoint = new TInfluxRow();
propertyMap.SetMeasurementName(name, dataPoint);
// go through all values that are stored as a List<List<object>>
for (int i = 0; i < values.Count; i++)
{
var value = values[i]; // TODO: What about NULL values? Are they treated as empty strings or actual nulls?
if (value != null)
{
setters[i](dataPoint, columns[i], value);
}
}
dataPoints.Add(dataPoint);
}
influxSerie.Rows.AddRange(dataPoints);
}
}
private static void AddValuesToInfluxSeriesByAttributes <TInfluxRow, TTimestamp>(
InfluxSeries <TInfluxRow> influxSerie,
SeriesResult series,
InfluxRowTypeInfo <TInfluxRow> propertyMap,
InfluxQueryOptions options,
ITimestampParser <TTimestamp> timestampParser)
where TInfluxRow : new()
{
// Values will be null, if there are no entries in the result set
if (series.Values != null)
{
var dataPoints = new List <TInfluxRow>();
var precision = options.Precision;
var columns = series.Columns;
var name = series.Name;
// construct an array of properties based on the same indexing as the columns returned by the query
var properties = new PropertyExpressionInfo <TInfluxRow> [columns.Count];
for (int i = 0; i < columns.Count; i++)
{
PropertyExpressionInfo <TInfluxRow> propertyInfo;
if (propertyMap.All.TryGetValue(columns[i], out propertyInfo))
{
properties[i] = propertyInfo;
}
}
foreach (var values in series.Values)
{
// construct the data points based on the attributes
var dataPoint = new TInfluxRow();
propertyMap.SetMeasurementName(name, dataPoint);
for (int i = 0; i < values.Count; i++)
{
var value = values[i]; // TODO: What about NULL values? Are they treated as empty strings or actual nulls?
var property = properties[i];
// set the value based on the property, if both the value and property is not null
if (property != null)
{
if (value != null)
{
if (property.Key == InfluxConstants.TimeColumn)
{
property.SetValue(dataPoint, timestampParser.ToTimestamp(options.Precision, value));
}
else if (property.IsDateTime)
{
property.SetValue(dataPoint, DateTime.Parse((string)value, CultureInfo.InvariantCulture, OnlyUtcStyles));
}
else if (property.IsEnum)
{
property.SetValue(dataPoint, property.GetEnumValue(value));
}
else
{
// will throw exception if types does not match up
property.SetValue(dataPoint, Convert.ChangeType(value, property.Type, CultureInfo.InvariantCulture));
}
}
}
}
dataPoints.Add(dataPoint);
}
influxSerie.Rows.AddRange(dataPoints);
}
}
private TextLogSource Create(string fileName,
ITimestampParser timestampParser = null)
{
return(new TextLogSource(_taskScheduler, fileName, LogFileFormats.GenericText, Encoding.Default));
}
public ILogEntryParser CreateParser(IServiceContainer services, ILogFileFormat format)
{
ITimestampParser timestampParser = services.TryRetrieve <ITimestampParser>() ?? new TimestampParser();
return(new GenericTextLogEntryParser(timestampParser));
}
/// <summary>
///
/// </summary>
/// <param name="timestampParser"></param>
public GenericTextLogEntryParser(ITimestampParser timestampParser)
{
_timestampParser = timestampParser ?? throw new ArgumentNullException(nameof(timestampParser));
_logLevelParser = new LogLevelParser();
_columns = new IColumnDescriptor[] { Core.Columns.Timestamp, Core.Columns.LogLevel };
}
/// <summary>
/// Initializes this parser.
/// </summary>
/// <param name="parser"></param>
public NoThrowTimestampParser(ITimestampParser parser)
{
_parser = parser ?? throw new ArgumentNullException(nameof(parser));
}
private SubtitleTimestampsParser CreateParser(ITimestampParser timestampParser)
{
return(new SubtitleTimestampsParser(timestampParser));
}
