Get all git commits since last tag

Navigating the intricate landscape of a project’s evolution can be a significant challenge for any developer or team. Understanding precisely what changes have been incorporated since the last major release or milestone is crucial for effective release management, debugging, and auditing. This process often involves sifting through countless individual contributions, but Git provides powerful tools to streamline this task. Effectively, knowing how to get all git commits since last tag empowers teams to generate accurate release notes, track feature implementations, and maintain clear transparency over their codebase. This article will delve into the essential commands and best practices to effortlessly retrieve this vital information, ensuring you always have a precise overview of your project’s development trajectory.

Understanding Git Tags and Their Importance

Git tags serve as permanent markers in your project’s history, pointing to specific commits. Unlike branches, which are designed to move, tags are fixed references to a particular point in time, typically used to mark release points such such as v1.0.0 or v2.1-beta. These markers are indispensable for version control, providing a stable reference that allows you to easily revisit specific states of your codebase. They are fundamental for robust project history tracking and ensuring consistency across deployments.

There are two primary types of tags in Git: lightweight and annotated. Lightweight tags are simply pointers to a commit, similar to a branch that doesn’t move. Annotated tags, on the other hand, are stored as full Git objects in the database. They contain additional metadata like the tagger’s name, email, date, and a tagging message, making them ideal for official releases. Industry experts, like Scott Chacon, co-author of “Pro Git,” emphasize the importance of annotated tags for production releases due to their rich metadata, which provides essential context for future audits and historical reviews. Leveraging tags effectively is the first step in efficiently knowing how to get all git commits since last tag, forming the backbone of predictable and auditable software deployments.

The Core Command: How to Get All Git Commits Since Last Tag

To accurately identify and list all commits that have occurred since your most recent tag, Git’s powerful git log command is your primary tool. This command allows for granular control over what information is displayed and how it’s formatted, making it incredibly versatile for various scenarios, from generating release notes to simply reviewing recent work. The key to retrieving commits since the last tag involves specifying a range, using the tag as the starting point.

To get all git commits since last tag, you’ll typically use git log <last-tag-name>..HEAD</last-tag-name>. This command shows all commits reachable from HEAD (your current branch) that are not reachable from <last-tag-name></last-tag-name>, effectively listing all changes made since that specific tag. For instance, if your last tag was v1.0.0, the command would be git log v1.0.0..HEAD. This provides a clear, chronological list of all modifications, ensuring no crucial update is missed in your project’s commit history.

Step-by-Step Usage:

Let’s break down the process into actionable steps to retrieve your commit history:

1. Identify the Last Tag: First, you need to determine the name of your most recent tag. You can list all tags in your repository using: ``` git tag –sort=-v:refname | head -n 1

   
    This command sorts tags in descending order by their name (useful for semantic versioning) and picks the top one, which is usually your latest.
   

2. Execute the Log Command: Once you have the tag name (let’s assume it’s v1.2.3), run the git log command, specifying the tag as the starting point: ``` git log v1.2.3..HEAD –oneline

   
    The `--oneline` flag provides a concise, single-line summary for each commit, including the commit hash and message, which is excellent for quick overviews.
   

3. Review the Output: The terminal will display a list of commits, starting from the most recent one up to the commit immediately following your specified tag. This output can be further customized with various flags, as explored in the next section.

Advanced Filtering and Customizing Your Commit Log

While the basic git log <tag>..HEAD</tag> command provides a solid foundation, Git offers an extensive array of options to filter and format the output, making it incredibly powerful for tasks like generating detailed release notes or performing specific audits. These advanced capabilities are essential for sophisticated release management in modern software development environments. By mastering these flags, you can transform a raw list of commits into structured, actionable information.

For instance, you might want to see only commits related to a specific feature or author. The --author="Name" flag filters commits by author, and --grep="pattern" allows you to search commit messages for specific keywords. Combine these with --pretty=format:"..." to craft highly customized output, perhaps including only the commit hash, author, and subject line. This level of detail is invaluable when trying to understand the full context of changes since a particular release and effectively helps to get all git commits since last tag, tailored to your exact reporting needs.

Practical Scenarios for Release Notes:

Consider a scenario where your team needs to generate release notes for version 2.0.0, building upon version 1.5.0. You would first find the tag for v1.5.0. Then, you could use a command like this to get a formatted list of commits:

git log v1.5.0..HEAD --pretty=format:" %s (by %an)" --no-merges

This command would output a bulleted list of commit subjects, along with the author’s name, excluding merge commits for a cleaner history. The --no-merges flag is particularly useful for focusing on direct feature and bug fix commits. Another common requirement is to see changes to specific files or directories, which can be achieved by adding paths to the end of the git log command, e.g., git log v1.5.0..HEAD -- path/to/feature. These techniques ensure that when you need to get all git commits since last tag, you also get them in the most Question & Answer :

When I’m going to tag a commit, I need to know what changed since the last tagged commit. Eg:

a87a6sdf87a6d4 Some new feature a87a6sdf87a6d3 Some bug fix a87a6sdf87a6d2 Some comments added a87a6sdf87a6d1 Some merge <- v1.4.0 

In this example I would like to know about the 3 newest commits, or be able to print a log like above, that shows both commits their tags if any. And when I see there has been a new feature added, I would tag it v1.5.0.

How do you deal with this? Is this how I’m supposed to use tags? What should I write in the tag message? I always leave it blank: git tag -a v1.2.3 -m ''

git log <yourlasttag>..HEAD 

If you want them like in your example, on the one line with commit id + message, then

git log <yourlasttag>..HEAD --oneline 

and in case you don’t know your latest tag or want this to be dynamic, on Linux / git bash / Windows bash you could do:

git log $(git describe --tags --abbrev=0)..HEAD --oneline 

and on Windows:

for /f "delims=" %a in ('git describe --tags --abbrev^=0') do @set latesttag=%a git log %latesttag%..HEAD --oneline 

Also, if you have a case where you know a tag in history and want to print everything from that tag up to current situation, you might want to add also --decorate so it would print out any tags in between.