React Lazylog

React components that load and view remote text in the browser lazily and efficiently.

Features

• Efficient scrolling performance thanks to react-virtualized
• Able to load large files upwards of 100MB without crashing the browser
• Parses, colorizes, and styles ANSI escapes within content
• Supports remote text files as well as chunked/streamed responses
• Line highlighting
• Customizable styling
• Works in latest browser versions, including iOS Safari and Android Chrome

Getting started

You can install react-lazylog via Yarn or npm:

# If using Yarn:
yarn add react-lazylog

# If using npm:
yarn add --save react-lazylog

The core components from react-lazylog are LazyLog and LazyStream. There is also a higher-order component (HOC) for following logs until scroll. This module can be required via ES imports, CommonJS require, or UMD.

import { LazyLog, LazyStream, ScrollFollow } from 'react-lazylog';

// full list of components
import {
  LazyLog,
  LazyStream,
  LazyList,
  ScrollFollow,
  Line,
  LineContent,
  LineNumber,
  LinePart,
  Loading,
  Spinner
} from 'react-lazylog';

// using require
const { LazyLog, LazyStream, ScrollFollow } = require('react-lazylog');

LazyLog and LazyStream inherit from LazyList.

<LazyLog /> & <LazyStream />

Usage

After importing a component, it can be rendered with the required url prop:

import React from 'react';
import { render } from 'react-dom';
import { LazyLog } from 'react-lazylog';

render((
  <LazyLog url="http://example.log" />
), document.getElementById('root'));

By default the LazyLog will expand to fill its container, so ensure this container has valid dimensions and layout. If you wish to have fixed dimensions, change the height and width props.

If you are going to be rendering a complete file, or an endpoint which can be downloaded all at once, use the <LazyLog /> component for better overall performance at the expense of slightly longer upfront load time.

If you are going to be requesting a streaming or chunked response, use the <LazyStream /> component for quicker upfront rendering as content can be decoded as it arrives.

Props

LazyLog and LazyStream accept various common props to customize their behavior:

In addition, most of the properties available to react-virtualized List can be provided and will be passed through to the component. Here are a few useful props:

<ScrollFollow />

ScrollFollow is a higher-order component (HOC) that aims to simplify toggling a LazyLog's or LazyStream's "follow" functionality based on user scrolling.

Usage

The ScrollFollow component accepts a function-as-child prop which should return a component to render based on the function's arguments.

import React from 'react';
import { render } from 'react-dom';
import { LazyLog, ScrollFollow } from 'react-lazylog';

render((
  <ScrollFollow startFollowing={true}>
    {({ follow, onScroll }) => (
      <LazyLog url="http://example.log" follow={follow} onScroll={onScroll} />
    )}
  </ScrollFollow>
), document.getElementById('root'));

Props

Child Function Properties

The child function passed to ScrollFollow is passed a single argument, an object with the following properties:

<ScrollFollow>
{({ onScroll, follow, startFollowing, stopFollowing }) => (
  <LazyLog url={'...'} onScroll={onScroll} follow={follow} />
)}
</ScrollFollow>

Styling

All of the components exposed from react-lazylog use CSS modules to contain its styles to each individual component. If you wish to override these styles, there are a few techniques you can use.

style and containerStyle

For the core container of <LazyLog /> and <LazyStream />, you can pass a style object prop to affect many styles. For affecting the look or behavior of the scrollable region of these components, use the containerStyle prop with a styling object.

defaultProps.style

For many react-logviewer components, continually passing varied styling objects is tedious. To make this simpler, you can override the defaultProps.style of any desired component to override styles of that component. For example:

// full list of components
import {
  Line,
  LineContent,
  LineNumber,
  LinePart,
  Loading,
  Spinner
} from 'react-lazylog';

// Use defaultProps.style to set the style for an internal component
Line.defaultProps.style = {
  color: 'green'
};

Note: overriding the ANSI colors and styles is currently undocumented, and will probably need some source-diving to figure out. I would gladly accept a pull request that could improve the styling API.

CSS stylesheets

If you are using CSS stylesheets, you can target the main virtual LazyList component with the react-lazylog class name. From there you can target the individual div lines, a line numbers, or span line content.

Sub-components

react-lazylog uses a number of sub-components internally to render individual parts of the log-viewing component:

<Line />

A single row of content, containing both the line number and any text content within the line.

<LineNumber />

The line number of a single line. The anchor contained within is interactive, and will highlight the entire line upon selection.

<LineContent />

The container of all the individual pieces of content that is on a single line. May contain one or more LineParts depending on ANSI parsing.

<LinePart />

An individual segment of text within a line. When the text content is ANSI-parsed, each boundary is placed within its own LinePart and styled separately (colors, text formatting, etc.) from the rest of the line's content.

Technology

• React Virtualized for efficiently rendering large lines of data
• Neutrino for building and developing using shared presets and Webpack
• neutrino-preset-react-components for creating and previewing React components
• PM2 for process management during development
• fetch API for efficiently requesting data with array buffers and binary streams
  • fetch-readablestream
  • web-streams-polyfill
  • text-encoding-utf-8
• ansiparse for nice log styling, like Travis
• mitt for dead-simple events to manage streaming lifecycle
• Immutable for efficiently storing and managing very large collections of lines and highlight ranges
• Uint8Array for dealing with text content as binary, allows for conditionally rendering partial data with decoding everything and crashing your browser

Development and Contributing

This repository uses Neutrino and neutrino-preset-react-components for developing, previewing, and building React components. To get started:

• Fork and clone this repo.
• Install the dependencies with yarn.
• Start the development servers with yarn start. This will launch a PM2 instance of webpack-dev-server and a Node.js server. Open a browser to http://localhost:9001 to preview the React components.
• Use CTRL-C to exit the PM2 server monitoring.
• Use yarn stop to stop the development servers.
• Use yarn build to generate the compiled component for publishing to npm.

Feel free to open an issue, submit a pull request, or contribute however you would like. Understand that this documentation is still a work in progress, so file an issue or submit a PR to ask questions or make improvements. Thanks!